# Duet: full site text
> One subscription for the best AI in writing, images, video and voice, plus agents that browse, research, and work in your apps. Nothing to set up.
Every public English page of https://duet.so, as markdown, rendered from the same sources the pages themselves render from. The index of these pages is at https://duet.so/llms.txt.
---
Source: https://duet.so
# Duet: Every Kind of AI in One Subscription, No Setup
The next thing is coming. This page is a work in progress. Leave your email and we’ll let you know when it’s ready.
## What it does
- The best AI models for writing, images, video, and voice, chosen automatically for each task
- Agents that browse the web and get things done on real websites
- 3,000+ app integrations, including Gmail, Slack, Notion, and Google Drive
- Built-in research on people, companies, contact details, search rankings, and social profiles
- Agents that remember, learn your work, and run on a schedule
- An always-on computer for every workspace
- Hosting for the pages, tools, and sites agents build
- Sharing agents, files, and apps with anyone
- One subscription, with no setup and no code
---
Source: https://duet.so/blog
# Blog
Playbooks, product updates, and deep dives on using Duet to run the workflows that actually make money.
## Posts
- [Gemini 3 Pro vs Claude Opus 4.8: The Complete Guide 2026](https://duet.so/blog/gemini-3-pro-vs-claude-opus-4-8.md): Gemini 3 Pro vs Claude Opus 4.8 compared on coding, reasoning, speed, and price. See which model wins each task and when to route between them.
- [How to Reduce LLM Cost Without Losing Quality: A Finance-First Decision Ladder](https://duet.so/blog/cut-enterprise-llm-spend.md): Cut enterprise LLM spend without hurting output quality. A finance-first, 9-step decision ladder — from seat waste to model right-sizing to routing.
- [AI Agents for Legacy Applications: What Amazon WorkSpaces Actually Solves (and What It Doesn't)](https://duet.so/blog/ai-agents-legacy-applications.md): Amazon WorkSpaces lets AI agents click legacy apps. Here's what that solves, what it doesn't, and the decision framework for SMB operators.
- [Does ChatGPT or Claude Train on Your Data? The Answer Depends on Your Account](https://duet.so/blog/does-chatgpt-claude-train-on-your-data.md): ChatGPT trains on consumer chats unless you opt out; Claude depends on a setting. See exactly what's safe by account type, plus a 5-minute audit.
- [What Is an Enterprise AI Stack — and Why Are Enterprises Ditching Single-Vendor AI?](https://duet.so/blog/enterprise-ai-stack.md): What is an enterprise AI stack? See the layers, lock-in risks, and a 90-day path enterprises use to go multi-model without a control plane.
- [Orchestrator-Worker LLMs vs. Model Routing: Which One Actually Cuts Your AI Costs?](https://duet.so/blog/frontier-model-orchestrator.md): Orchestrator-worker patterns boost quality, not cost. Model routing cuts spend. Anthropic and RouteLLM data on which lever to pull, and when.
- [AI Agent Workspace vs. Control Plane: What Do You Need After the Demo?](https://duet.so/blog/ai-agent-workspace-vs-control-surfaces.md): Compare persistent workspaces, execution environments, and agent control planes, then choose the ownership, proof, and recovery model your workflow needs.
- [AI Automation Agency Guide: Build, Deploy, and Run Client Agents](https://duet.so/blog/ai-automation-agency-guide.md): A practical AI automation agency guide to scoping client agents, choosing runtime ownership, operating responsibly, improving the system, and planning a clean handoff.
- [Open Source AI Models for Business: Is Kimi K3 the End of the Per-Seat AI Bill?](https://duet.so/blog/kimi-k3-open-source-ai-models.md): Kimi K3 launched open-weight. Here's the seats-vs-tokens math: when per-token AI pricing beats fixed seat subscriptions for SMB teams.
- [Grok 4.5 vs Claude Opus 4.8: Which Should You Actually Use in 2026?](https://duet.so/blog/grok-4-5-vs-claude-opus-4-8.md): Grok 4.5 vs Claude Opus 4.8 compared: pricing, coding benchmarks, context windows, and reliability. Plus the smarter way to run or route between both without lock-in.
- [8 MCP Servers for Claude Code You Can Actually Defend (2026)](https://duet.so/blog/mcp-servers-for-claude-code-examples.md): MCP server examples for Claude Code, vetted for safety and maintenance. 8 servers across code, databases, and web grounding, with live-verified install commands.
- [Package Your Expertise Into an AI Agent You Can Sell](https://duet.so/blog/package-your-expertise-into-an-ai-agent.md): Learn how to sell AI agents built from your own expertise — no code required. A concrete, step-by-step guide to package, price, and run one.
- [How to Price an AI Agent Retainer (And Turn One-Off Builds Into Recurring Revenue)](https://duet.so/blog/turn-ai-agent-builds-into-recurring-retainers.md): A pricing framework, SOW clause, and pitch script for turning one-off AI agent builds into recurring retainers — with the real margin math.
- [Where Should You Host Your AI Agents? A 2026 Decision Guide](https://duet.so/blog/where-to-host-ai-agents.md): Not sure where to host your AI agents? Compare DIY VPS, serverless, and managed runtimes on real cost and uptime risk.
- [Who Runs Your AI Agent After You Build It?](https://duet.so/blog/who-runs-your-ai-agent-after-you-build-it.md): AI agent maintenance defaults to the builder. The three handoff models, real retainer pricing, and how to run client agents without pager duty.
- [How to Benchmark AI Models on Real Work (Not Leaderboards)](https://duet.so/blog/how-we-benchmark-ai-models-on-real-work.md): Leaderboards test models on invented prompts. Here's how to benchmark AI models on real work — completion, switch-away, tool reliability, and blind quality.
- [Best Way to Access Claude Code on Mobile in 2026](https://duet.so/blog/claude-code-mobile-iphone-android.md): Learn how to use Claude Code from your phone. Duet's iOS and Android apps let you check agents, tweak prompts, and ship code from anywhere, no desktop required.
- [Claude Code Skills Marketplace 101](https://duet.so/blog/claude-code-skills-marketplace.md): Learn where to find Claude Code skills, how to review them safely, and how to keep reusable instructions in a Duet workspace without depending on a proprietary catalog.
- [When NOT to Use Claude Fable 5 (6 Cases Where Opus 4.8 Wins)](https://duet.so/blog/when-not-to-use-claude-fable-5.md): Claude Fable 5 costs $10/$50 per MTok — Anthropic's most expensive model. Before you default to it, here's exactly when Opus 4.8, Sonnet, or Haiku wins instead.
- [Open Claw vs Hermes vs Duet: Which AI Agent Is Actually Right for You?](https://duet.so/blog/duet-vs-open-claw-vs-hermes.md): Open Claw is a developer tool. Hermes is agent infrastructure. Duet is a cloud workspace that runs business workflows without any installation. Here's the honest comparison.
- [Loops vs Duet Boards — How to Run Autonomous Workflows Without Writing a Single Script](https://duet.so/blog/loops-vs-duet-boards.md): Peter Steinberger says design loops, not prompts. Here's what that means if you're not a developer — and how Duet Boards let you run it without code.
- [Top 10 Claude Code Hooks to Use in 2026](https://duet.so/blog/claude-code-hooks.md): Copy-paste 10 Claude Code hooks into your settings.json today. Auto-format files, block destructive commands, get notifications, enforce git workflows, and more.
- [Duet vs OpenAI Workspace Agents vs Claude for Small Business vs Viktor (2026 Guide)](https://duet.so/blog/duet-vs-openai-workspace-agents-vs-claude-for-small-business-vs-viktor.md): Duet, OpenAI Workspace Agents, Claude for Small Business, and Viktor compared on persistence, team fit, build+run, integrations, pricing, and SMB fit.
- [Slack Alternatives in 2026: Honest Comparison](https://duet.so/blog/slack-alternatives-with-ai-agents-2026.md): Slack and Teams compared with Duet and other AI workspaces in 2026: human coordination, persistent agents, app hosting, and private cloud workspaces.
- [How Duet Builds Agent Memory with Context Graphs](https://duet.so/blog/how-duet-builds-and-evals-context-graphs.md): Context engineering is more than a bigger window. A context graph captures the why behind every agent decision — what was weighed, rejected, and overridden. How Duet records and evals it.
- [How to Choose the Right AI Model for Your Business: Grok vs Gemini vs Claude vs GPT-5.5](https://duet.so/blog/how-to-choose-the-right-ai-model-for-your-business.md): A practical guide to picking the right AI model per task — Claude for writing, GPT-5.5 for code, Gemini for long context, Grok for real-time. How to run all four without four logins.
- [Duet vs Claude for Small Business: Which AI Runs Your Workflows in 2026?](https://duet.so/blog/duet-vs-claude-for-small-business.md): Anthropic's Claude for Small Business vs Duet compared on workflows, integrations, pricing, and setup. Which AI actually runs your business?
- [Codex vs Claude Code: Which AI Coding Agent Wins in 2026?](https://duet.so/blog/codex-vs-claude-code.md): Codex vs Claude Code compared: SWE-bench scores, $20 to $200 pricing, speed, and security. Which AI coding agent should you use in 2026? Full breakdown with a clear verdict.
- [Claude Opus 4.7, GPT-5.4 & Extended Thinking: Pick Your AI Agent Model in Duet](https://duet.so/blog/claude-opus-4-7-gpt-5-4-extended-thinking-duet.md): Most AI agent failures come from using the wrong model. Duet lets you pick the model and thinking depth per agent: Claude Opus 4.7, GPT-5.4, and more, so every task gets the right brain.
- [Custom Domains for AI-Built Apps: Setup Guide for Duet](https://duet.so/blog/custom-domain-names-in-duet.md): AI-built tools on generic subdomains look like demos. Custom domains in Duet let you ship internal tools and client-facing apps on your own URL, with automatic HTTPS, in minutes.
- [Claude Code Pricing in 2026: Plans, Token Costs, and the Cloud Option](https://duet.so/blog/claude-code-pricing.md): How much does Claude Code cost? Claude Pro is $20/mo, Claude Max is $100–$200/mo, plus API token costs, the cloud option, and a full plan comparison for 2026.
- [6 Best AI Agent Builders in 2026](https://duet.so/blog/6-best-ai-agent-builders-in-2026.md): A practical comparison of the 6 best AI agent builders in 2026, each picked for a specific type of team and use case.
- [How We Grew Google Traffic 800% in 6 Weeks With AI](https://duet.so/blog/how-we-grew-google-traffic-800-percent-with-ai.md): 800% traffic growth in 6 weeks using AI-assisted content strategy. Here's exactly what we did and what you can replicate.
- [How We Automated Our Weekly Product Newsletter With AI](https://duet.so/blog/how-we-turned-github-history-into-automated-newsletter.md): Two hours to write one newsletter. Every week. Here's how Duet automated it — and how you can do the same for any recurring update.
- [Why We Replaced MCP With Code Execution Agents](https://duet.so/blog/mcp-alternatives-code-execution-agents.md): MCP looked promising. Then we tried code execution agents and never looked back. Here's what changed our minds.
- [How to Automate Dropshipping Product Research with AI](https://duet.so/blog/automate-dropshipping-product-research-ai.md): Stop manually checking AliExpress and TikTok. Build an automated AI agent pipeline to find, score, and alert you of winning dropshipping products.
- [Claude Code vs Cursor vs Codex (2026): Which AI Coder Wins](https://duet.so/blog/claude-code-vs-cursor-vs-codex.md): Honest 2026 comparison of Claude Code, Cursor, and Codex — speed, pricing, agent quality, and when to pick each. Updated for Opus 4.7 and GPT-5.5.
- [Build a Dropshipping Automation Dashboard with AI](https://duet.so/blog/dropshipping-automation-dashboard-ai.md): One dashboard to rule your entire dropshipping operation. Build a fully automated tracking and alert system with AI — no code needed.
- [AI-Powered Dropshipping Competitor Monitoring Setup](https://duet.so/blog/dropshipping-competitor-monitoring-ai.md): See every move your competitors make before it hits your sales. Set up automated dropshipping competitor monitoring with AI.
- [Build a Dropshipping Price Monitor with AI Alerts](https://duet.so/blog/dropshipping-price-monitor-ai-alerts.md): Never get undercut again. Build a live price monitor with instant AI alerts so you're always the lowest price that matters.
- [Find Reliable Dropshipping Suppliers Using AI](https://duet.so/blog/find-dropshipping-suppliers-ai-web-scraping.md): Bad suppliers kill dropshipping businesses. Use AI to vet, find, and compare reliable suppliers before they cost you customers.
- [How to Automate Bookkeeping and Reporting with AI](https://duet.so/blog/how-to-automate-bookkeeping-financial-reporting-ai.md): Receipts in email, invoices in spreadsheets, tax season panic. Here's how to automate your bookkeeping and financial reporting with AI — for good.
- [How to Automate Competitive Intelligence for Your Startup](https://duet.so/blog/how-to-automate-competitive-intelligence-startup.md): Your competitors are moving fast. Automate your competitive intelligence so you're never caught off guard again.
- [How to Automate Content Creation as a One-Person Business](https://duet.so/blog/how-to-automate-content-creation-one-person-business.md): 15 hours a week on content. Or 3. AI-powered content automation for one-person businesses — blog posts, social, newsletter, all of it.
- [Build an AI-Powered SEO Strategy Without an Agency](https://duet.so/blog/how-to-build-ai-seo-strategy-without-agency.md): Fire your SEO agency or save the $5K/month before hiring one. Build an AI-powered SEO strategy that actually ranks.
- [Build and Deploy a Web App Using Only AI](https://duet.so/blog/how-to-build-and-deploy-a-web-app-using-only-ai.md): No dev team? No problem. Build and ship a fully functional web app using only AI — from idea to deployed in days.
- [Build a Client Analytics Dashboard Without a Dev](https://duet.so/blog/how-to-build-client-analytics-dashboard-without-developer.md): Give clients real-time analytics dashboards without hiring a developer. Build it in a day using AI — seriously.
- [How to Build and Ship an Internal Tool in a Day Using AI](https://duet.so/blog/how-to-build-internal-tool-in-a-day-with-ai.md): Your team needs it, engineering is backlogged. Build and ship a working internal tool in a single day using AI — no dev required.
- [Create Professional Marketing Videos with AI](https://duet.so/blog/how-to-create-marketing-videos-with-ai.md): AI marketing video creation without a video team — the text to video for marketing workflow that ships scroll-stopping videos in hours.
- [How to Deliver Client SEO Audits in Hours Instead of Weeks](https://duet.so/blog/how-to-deliver-client-seo-audits-in-hours.md): Stop burning 3 weeks on SEO audits. Deliver comprehensive client audits in hours using AI, and charge the same rates.
- [Generate Branded Social Media Content In An Hour](https://duet.so/blog/how-to-generate-branded-social-media-content-at-scale.md): Stop posting one-off. Generate weeks of on-brand social content in an hour using AI. Consistent voice, zero burnout.
- [How to Host OpenClaw in the Cloud (Always On)](https://duet.so/blog/how-to-host-openclaw-in-the-cloud.md): Deploy OpenClaw on a VPS or managed platform for 24/7 AI agent operation with Docker, security best practices, and cost analysis.
- [Run Claude Code in the Cloud 24/7 (No Laptop Needed)](https://duet.so/blog/how-to-run-claude-code-in-the-cloud.md): Run Claude Code on a persistent cloud server — sessions stay alive for days, work from your phone, no laptop required. Full setup in 5 minutes.
- [How to Scale a Marketing Agency to 20 Clients Without Hiring](https://duet.so/blog/how-to-scale-marketing-agency-without-hiring.md): Scaling an agency without headcount sounds impossible. Here's how AI agents let you run 20 clients without burning out.
- [Scrape, Analyze, and Monitor Any Website with AI](https://duet.so/blog/how-to-scrape-analyze-and-monitor-any-website.md): Turn any website into a live data feed. Scrape, analyze, and monitor competitors or prospects with AI. Fully automated.
- [How to Run Claude Code 24/7: Setup Guide for Always-On AI Agents](https://duet.so/blog/how-to-set-up-a-24-7-ai-agent.md): Run Claude Code 24/7 without babysitting sessions. Compare tmux, systemd, and Docker to a persistent, zero-setup server that keeps your AI agent always on.
- [Set Up an AI Customer Service Agent for Your Biz](https://duet.so/blog/how-to-set-up-ai-customer-service-small-business.md): Replace your support backlog with an AI agent that resolves tickets 24/7. Set it up in an afternoon. No ML degree required.
- [How to Set Up AI-Powered Sales Prospecting for Your Startup](https://duet.so/blog/how-to-set-up-ai-sales-prospecting-startups.md): Find your next 100 customers in hours, not weeks. AI-powered sales prospecting that actually converts for early-stage startups.
- [How to Use AI as Your Personal Research Assistant](https://duet.so/blog/how-to-use-ai-as-personal-research-assistant.md): Stop spending 8 hours on research that should take 20 minutes. Here's how to use AI as your personal research assistant. For sales, competitive analysis, and lead building.
- [How to Use AI for Market Research Before Launch](https://duet.so/blog/how-to-use-ai-for-market-research-before-launch.md): Validate your idea before you build it. Use AI to run market research that would normally cost $10K and 3 months.
- [Use AI to Find High-Intent Freelance Prospects](https://duet.so/blog/how-to-use-ai-to-find-prospects-for-freelance-business.md): Stop chasing cold leads. Use AI to find freelance prospects who already need what you offer, and reach them first.
- [Use AI to Run Startup Ops with a 3-Person Team](https://duet.so/blog/how-to-use-ai-to-run-startup-operations-with-a-3-person-team.md): Three people, ten people's worth of ops. Here's how a small startup team uses AI to run operations without burning out or hiring.
- [Write Sales Emails with AI That Actually Get Replies](https://duet.so/blog/how-to-use-ai-to-write-sales-emails-that-get-replies.md): Most AI sales emails get ignored. Here's the exact framework to write AI-powered emails that get real replies from real people.
- [Write High-Converting Ad Copy with AI](https://duet.so/blog/how-to-write-high-converting-ad-copy-with-ai.md): Ad copy that actually converts starts with the right AI prompts. Here's the framework we use to write ads that hit.
- [OpenClaw Alternatives Compared: Self-Hosted vs Managed AI Agents (2026)](https://duet.so/blog/openclaw-vs-managed-ai-agent-platforms.md): Not sure if you should self-host OpenClaw or use a managed AI agent platform? Compare costs, security, team features, and setup to find the right approach.
---
Source: https://duet.so/blog/6-best-ai-agent-builders-in-2026
# 6 Best AI Agent Builders in 2026
*A practical comparison of the 6 best AI agent builders in 2026, each picked for a specific type of team and use case.*
By Duet Team. Published 2026-04-21, updated 2026-05-08. 13 min read.
In 2025, everyone was building AI agent demos.
In 2026, they're replacing line items on the org chart.
Agents that were "cool Twitter clips" twelve months ago are now booking meetings, triaging support tickets, qualifying leads, and shipping code, in production, on real budgets, for real teams.
However, there are 50+ "AI agent builders" on the market, and most comparison posts read like an auto-generated list of the same ten names.
They don't tell you _who each tool is actually for_, so you end up with a trial account in four of them and no agent in production.
In this blog, we've picked 6 platforms, each one genuinely best for a specific type of team.
Skip ahead to the use case that matches yours, or read the whole thing in 8 minutes.
**Best AI Agent Builders in 2026**
The 6 best AI agent builders in 2026 are n8n (technical/self-hosted teams), Lindy (no-code SMB ops), Relevance AI (multi-agent workforces), Duet (persistent agent workspace), CrewAI (code-first multi-agent orchestration), and Microsoft Copilot Studio (enterprise M365 ecosystem). Each excels at a different use case.
## What is an AI Agent Builder?
An AI agent builder is a platform that lets you deploy software that can **reason, plan, and take action** across your tools, not just answer questions in a chat window.
The distinction matters. Classic automation tools like Zapier follow a rigid "if-this-then-that" script. Agent builders use an LLM as the decision-maker, so the agent can handle fuzzy inputs, pick its own next step, and recover when something changes mid-workflow.
In 2026, the line between the two is blurring. Most top agent builders now sit on a spectrum: deterministic at the edges (triggers, integrations, guardrails), non-deterministic in the middle (the reasoning loop). The "best" tool depends on where you need that balance struck.
## What Changed Between 2025 and 2026
Three shifts reshaped this category in the last twelve months:
### MCP went mainstream
Announced by Anthropic in late 2024, MCP is now the default way agents talk to external tools. If a builder you're evaluating doesn't support MCP, that's a red flag. Interop is the new table stakes.
### Autonomous execution became real
2025 agents needed constant hand-holding. 2026 agents run for hours unsupervised, with memory that persists across sessions. That unlocks long-horizon tasks: research reports, multi-step outbound, full customer onboarding flows.
### No-code caught up with code-first
Visual builders now ship features (memory, multi-agent orchestration, custom tool calls) that used to require a Python repo. The gap isn't gone, but it's narrow enough that most SMB teams no longer need an engineer.
## The 6 Best AI Agent Builders in 2026
We shortlisted these six from a field of ~40 based on four criteria: production-ready (not just demo-ware), active development in the last 90 days, distinct positioning (no two tools solve the same problem), and real user traction on G2 and Reddit.
Pricing and specs were verified at publish time.
### [n8n](https://n8n.io/): Best for technical teams
Founded in Berlin by Jan Oberhauser in 2019, n8n started life as an open-source alternative to Zapier. One you could self-host, extend in JavaScript, and actually read the source code of. That "fair-code" ethos gave it a cult following long before agents were the default.
When the AI wave hit in 2024, n8n shipped LangChain nodes early and became the go-to stack for builders who wanted agents _and_ data residency. Today it's one of the most-starred automation projects on GitHub, with a community that skews hard toward DevOps and AI-native teams.
**Standout:** Native LangChain integration, first-class AI agent nodes, and the rare ability to run it entirely on your own infrastructure. If data residency or per-execution pricing is a blocker elsewhere, n8n usually solves it.
**Best for:** DevOps and platform teams, privacy-sensitive orgs, and anyone who'd rather self-host than pay per run.
**Pricing:** Free self-hosted; Cloud starts at $20/month (2,500 executions).
**Honest tradeoff:** The learning curve is real. If nobody on your team has touched a Docker container, start somewhere else.
### [Lindy](https://www.lindy.ai/): Best no-code builder for SMB daily operations
Lindy was founded in 2022 by Flo Crivello, an early Uber engineer who bet (well before the rest of the market) that "AI assistants" would eat vertical SaaS one category at a time. In 2023 that looked speculative. By 2026, it's the default.
Lindy rode that thesis from a personal productivity app to a full agent platform, and they've been consistently early on the features that now define the category: conversational triggers (email, Slack, calendar), long-term memory, and human-in-the-loop approval flows. If you're a non-technical operator who wants an agent running back-office workflows by end of day, Lindy is usually the fastest path there.
**Standout:** 3,000+ integrations and trigger sources out of the box, with a natural-language builder that actually understands things like _"every time a new lead fills out the form, enrich them and add to the SDR queue."_
**Best for:** Small teams, solopreneurs, and ops leaders automating recurring back-office work without an engineering team to support it.
**Pricing:** Free tier available; paid plans start at $49/month.
**Honest tradeoff:** Less flexibility for complex multi-agent orchestration. If you need agents delegating to each other, you'll outgrow it.
### [Relevance AI](https://relevanceai.com/): Best for building AI "workforces"
Relevance AI was founded in Sydney in 2020 by Daniel Vassilev and Jacky Koh, originally as a vector search and embeddings platform. When agents became the story in 2023, they pivoted hard and, more importantly, reframed the category. Instead of selling "AI automation," Relevance sells _AI employees_:
Bosh the BDR, Apla the AI recruiter, Liza the legal assistant. That framing sounded gimmicky two years ago. In 2026, it's driving enterprise RFPs, because "replace a headcount" is a line item a CFO can actually budget against. Relevance was also early on agent-to-agent delegation, which matters now that most real workflows involve multiple specialists handing off to each other.
**Standout:** Agent-to-agent delegation, role-based agent templates, and strong memory tooling that makes long-running tasks (multi-touch outbound, weeks-long recruiting loops) actually viable.
**Best for:** Companies looking to augment or replace revenue-facing functions (SDR, BDR, CS, recruiting) with a coordinated team of agents rather than a single bot.
**Pricing:** Starts at $19/month; team plans scale based on usage.
**Honest tradeoff:** Overkill if you just need to automate one workflow. The platform's strength is agent coordination, so a single-agent use case underutilizes it.
### [Duet](/): Best AI Agent Builder of 2026
Duet was founded in 2025 by David Zhang on a simple bet: an AI agent becomes useful when it has durable work history, business context, and its own environment to finish real jobs. Sessions, files, trained memory, integrations, and hosted apps keep that work in one workspace instead of scattering it across disposable prompts.
A year in, that bet is aging well. Duet is a platform for running durable AI sessions inside a shared workspace. Each session runs in its own secure sandbox and can handle automations, workflows, internal tool building, and more while keeping its files and event history available for the next job.
**Standout:** Duet offers deep managed integrations (accessing 500+ apps), writes integration code on the fly with native agentic coding capabilities, and keeps sessions beside workspace files, trained memory, integrations, and hosted apps. The agent can work from durable context instead of a disposable prompt.
Unlike competitors that gate model access behind platform fees, Duet passes LLM tokens through _at cost_. Claude Opus 4.7, Sonnet 4.6, GPT 5.4, plus 900+ content creation models, with no markup.
**Best for:** Teams who want one platform that combines durable AI sessions, memory, integrations, files, and internal tooling instead of stitching five SaaS tools together and crawling in terminals all day.
**Pricing:** Start with a 7-day free trial, no credit card. Then choose Starter, Pro, or Max; each monthly plan includes credits, and paid-reserve topups cover overage. Enterprise procurement support is available for security reviews and custom terms.
**Who it's for:** Forward-leaning teams ready to consolidate agent work, files, memory, integrations, and hosted tooling into one platform instead of stitching together five SaaS tools that never quite talk to each other.
_Full disclosure: this post is on the Duet blog; Duet is listed alongside five other platforms we use and respect._
[**Try Duet free →**](https://app.duet.so/sign-in?from=pricing)
### [CrewAI](https://crewai.com/): For code-first multi-agent orchestration
CrewAI was started in late 2023 by Joao Moura, a long-time engineer who'd built ML systems at IBM and Clearbit before convincing himself that most agent frameworks were modeling the problem wrong. His insight: agents shouldn't be configured like tools, they should be staffed like teams, each with a role, a goal, and a backstory that shapes how they reason. That framing caught on fast.
CrewAI has become one of the most-starred AI agent projects on GitHub and quietly influenced how most modern multi-agent systems are designed today. If you're an engineer who wants full programmatic control over how agents collaborate, delegate, and escalate, this is the framework that got there first.
**Standout:** Role/Goal/Backstory/Task primitives that make complex agent crews legible. Not a tangle of prompt strings held together with string concatenation.
**Best for:** Engineering teams shipping custom agent products and anyone who'd rather write Python than drag boxes on a canvas.
**Pricing:** Open-source and free; Enterprise tier with hosting, observability, and support (contact sales).
**Honest tradeoff:** No UI. You're writing code. If that's a blocker, it's a blocker.
### [Microsoft Copilot Studio](https://adoption.microsoft.com/en-us/ai-agents/copilot-studio/): For enterprise and the Microsoft ecosystem
Copilot Studio is Microsoft's low-code agent builder, launched in late 2023 as an evolution of Power Virtual Agents. You don't think of Microsoft as the scrappy AI story of 2026, but that's exactly why this tool matters.
For the thousands of F500 teams already running M365, Azure, and Dynamics, procurement, compliance, and SSO are already solved. Building an agent with Copilot Studio skips six months of security review that any challenger platform would have to fight through from scratch. It's not the most exciting tool on this list. It is, for a specific kind of buyer, the most realistic one to actually get signed off and deployed this quarter.
**Standout:** Native integration with Teams, Outlook, SharePoint, and Dynamics, plus enterprise-grade governance, audit logs, DLP, RBAC, baked into the same tenant your IT team already manages.
**Best for:** Enterprises already on the Microsoft stack where compliance and procurement friction matter more than tool flexibility.
**Pricing:** Starts at $200/month for 25,000 messages; overage and premium message tiers apply.
**Honest tradeoff:** Lock-in. You're buying deeper into the Microsoft ecosystem, which is great if you're already there and expensive to unwind if you're not.
---
## Quick Comparison
_In short, most tools above are great at one thing. Duet is built as an end-to-end agent workspace: durable sessions, memory, files, integrations, apps, and a cloud VM where the agent can build and ship._
---
## How to Choose the Right Tool for You
The wrong question is _"which tool is best?"_ The right one is _"where does the friction sit in my team?"_ Run this decision tree:
- **You want one platform that replaces five?** (sessions + agents + memory + integrations + internal tooling): Duet.
- **You want agents in the same surface your team already uses every day:** Duet.
- **You want agents delegating to each other like a real team:** Relevance AI for revenue functions, CrewAI if you're code-first.
- **You're deep in Microsoft 365 and procurement is the blocker:** Copilot Studio.
- **Data residency is a hard line:** n8n self-hosted, or CrewAI on your own infra.
- **You want tight, single-purpose workflow automation:** Lindy.
The uncomfortable truth most comparison posts skip: the fanciest agent builder in the world loses if your team forgets to open it. That's why 2026's winning agents increasingly live where teams already communicate, not behind yet another dashboard login.
---
## Epilogue
The "best" AI agent builder in 2026 is the one your team will actually use on Friday afternoon. Every tool on this list is production-ready. The variable is whether the agent lives somewhere your team naturally shows up.
That's the quiet bet behind Duet, and it's the direction the whole category is moving: agents converging with team communication, MCP making tools interoperable, and the per-app workflow silo fading out. If you're evaluating agent builders right now, pick for where your team works, not where the dashboard sits.
---
Source: https://duet.so/blog/ai-agent-workspace-vs-control-surfaces
# AI Agent Workspace vs. Control Plane: What Do You Need After the Demo?
*Compare persistent workspaces, execution environments, and agent control planes, then choose the ownership, proof, and recovery model your workflow needs.*
By Duet Team. Published 2026-07-17, updated 2026-07-17. 15 min read.
An AI agent workspace is the persistent operating environment where task state, context, files, permissions, schedules, and outputs remain available. An agent control plane provides capabilities to observe, govern, and intervene, while an execution environment gives agents somewhere to act. One product may combine all three jobs; the distinction is about capabilities, not vendor categories.
The real test comes after the demo: what remains running, reviewable, owned, and recoverable after the builder closes the laptop or leaves the account?
That gap doesn't show up in a fifteen-minute demo. It shows up in week three, when the builder isn't in the room.
## TL;DR
- Workspace, execution environment, and control plane are three different jobs. One product can cover one, two, or all three, so compare capabilities, not labels.
- Persistence and "it runs in the cloud" prove almost nothing alone. What matters is what survives a restart and who owns it.
- The agent's own "done" message is a claim, not proof. Verify consequential work at the destination system itself.
- After the demo, name four owners (business, workflow, system, incident) and confirm a non-builder can run and recover the workflow.
- Match the tool to the risk: one-off work needs execution, recurring work needs durable state, unattended work needs state plus real intervention.
## What is an AI agent workspace?
An **AI agent workspace** is a persistent environment that keeps selected task state, context, files, permissions, schedules, outputs, and history available across sessions, not just while one chat tab or process stays open.
A transcript proves nothing by itself, nor does "it runs in the cloud." The narrower question: what survives a restart, and who's responsible for it?
[Cloudflare's reference architecture for an enterprise AI agent workspace](https://developers.cloudflare.com/reference-architecture/diagrams/ai/enterprise-ai-agent-workspace/) describes a workspace authority that owns conversations, tasks, schedules, consent decisions, and an event queue, with outputs that outlive the conversation and webhooks that start work without an open browser.
On April 22, 2026, OpenAI announced workspace agents in ChatGPT: cloud-based, Codex-powered agents with a workspace of files, code, tools, and memory that keep running while the user is away, on schedules, inside ChatGPT or Slack. OpenAI's own page describes this as a research preview for ChatGPT Business, Enterprise, Edu, and Teachers. One vendor's current example, not a universal blueprint.
**Persistent does / does not prove:**
| Persistent proves | Persistent does not prove |
| ----------------------------------------------------------------- | ------------------------------------------------------------- |
| Selected state, files, or outputs survive a restart or closed tab | The state is complete, correct, or reconciled against reality |
| Schedules or webhooks can trigger work without a person present | Anyone has reviewed what the schedule produced |
| History exists to inspect later | The history is owned by someone who will act on it |
## What does an agent control plane do?
An **agent control plane** gives people or policy the ability to observe, govern, and intervene in agent work: registry, identity, lifecycle, telemetry, audit, and approvals.
None of that tells you whether the underlying work has a durable home. A control plane can sit on stateful or stateless work.
[Microsoft Agent 365](https://www.microsoft.com/en-us/microsoft-agent-365) fits this positioning: a control plane for observing, governing, and securing agents, with a registry, analytics, lifecycle policies, audit/security controls, and handling for ownerless agents. IBM's explainer broadens the definition to include execution and state/memory management. "Control plane" isn't shorthand for "dashboard only." Galileo describes its open-source Agent Control, announced March 11, 2026, as a control plane for centralized runtime governance.
A working control plane checklist:
- **Observe**: see what's running and what it touched
- **Govern**: apply policy before and during execution
- **Approve**: require sign-off at defined checkpoints
- **Intervene**: pause, stop, or redirect a live run
- **Audit**: produce a record after the fact
## Workspace, execution, or control: which does what?
Workspace, execution, and control are three **operational jobs**, not three exclusive vendor categories. A single product can supply one, two, or all three.
Sorting vendors into rigid buckets is the fastest way to misjudge a stack; ask what capability is implemented, by which layer.
| Operational job | Capabilities | What it proves | What it does not prove | Questions to ask |
| ----------------------- | -------------------------------------------------- | ------------------------------------------- | --------------------------------------------- | --------------------------------------------------------- |
| Persistent workspace | State, files, schedules, history, handoff material | Context and outputs survive across sessions | Correctness or that anyone reviews the output | What persists, and who can read or export it? |
| Execution environment | API, shell, browser, sandbox, or managed desktop | The agent has somewhere to act | Durable state or governance over the action | Where does it run, and what happens if interrupted? |
| Control plane / surface | Observe, govern, approve, pause, audit | People or policy can see and intervene | A durable home or verified output | Can a non-builder pause this safely, with an audit trail? |
AWS WorkSpaces for AI agents shows how one product can combine managed desktop execution with observation and intervention controls. Its page describes agents operating enterprise apps through MCP, view-only observation, pause/stop intervention, CloudTrail tool-call logs, CloudWatch session metrics, and S3 screenshots. Evaluate any additional workspace or persistence requirements separately.
## How do you hand off AI agents after the demo?
Managing agents after the demo means mapping authoritative state, then assigning four named owner roles so the workflow survives a change of operator.
For every piece of state this workflow touches (files, credentials, schedules, approvals), ask where the real answer lives. "Wherever the agent last wrote it" is a gap.
**Four owner roles for the operating contract:**
| Role | Responsible for |
| -------------- | ------------------------------------------------ |
| Business owner | Outcome, risk tolerance, budget, approval policy |
| Workflow owner | Inputs, exceptions, output quality, schedule |
| System owner | Runtime, connectors, credentials, versions |
| Incident owner | Triage, containment, reconciliation, recovery |
One person may hold several roles, but no role should be implicit. This is an article-created framework, not a standard body's taxonomy. NIST's AI RMF Playbook makes an adjacent point in general risk-management terms (defined roles, review, inventories, decommissioning, recovery), useful background, not a source for this split.
Before calling a handoff done, run this checklist:
1. Access moves to client-controlled accounts where appropriate, not the builder's personal login.
2. Credentials have a documented revocation and rotation path.
3. Schedules are owned and visible to someone who isn't the builder.
4. Data and outputs are exportable, not trapped in one interface.
5. Approval boundaries are written down, not remembered.
6. A **non-builder** can run and recover the workflow without calling the consultant.
That's the real test. If [who maintains the agent after handoff](/blog/who-runs-your-ai-agent-after-you-build-it) is still open three weeks in, the handoff didn't happen. It was a demo with a longer runway.
## What proves an AI agent finished the work?
An agent's own "done" message is a claim, not proof. Completion has to be verified against the destination system that holds the result.
Treat every consequential task as a seven-link chain. Trust almost always breaks right after execution, before anyone checks the destination.
**The seven-step evidence chain:**
1. **Intent**: the outcome that was actually requested
2. **Authorization**: the allowed action and its scope
3. **Execution**: the attempt, with a run ID
4. **Destination receipt**: an object, message, or deployment ID from the target system
5. **Independent verification**: a readback, query, health check, or review
6. **Artifact and provenance**: the output plus its source and version
7. **Closure**: terminal state, exceptions, owner, and next action
The critical transition is step 3 to step 4: the agent's own success message is never destination truth. Kubernetes' controller documentation illustrates the underlying principle, reconciling actual state toward desired state, though that page was last modified September 1, 2024, so treat it as background, not fresh evidence.
**Hypothetical destination checks, by task type:**
| Task | "Done" claim | Actual proof |
| ---------- | ------------------------------ | ------------------------------------------------------------------ |
| Email send | Agent reports message sent | Provider delivery receipt and a lookup in Sent items |
| CRM update | Agent reports record updated | The CRM record itself, queried independently |
| Deployment | Agent reports build succeeded | A deployment ID plus a live smoke test against the running service |
| Report | Agent reports report generated | A dated report tied to its source inputs, opened and checked |
The systems vary; the pattern doesn't.
## How do you recover a failed agent workflow?
Recover in a fixed sequence: STOP, SCOPE, RECONCILE, RESUME, PROVE, LEARN, so you never retry a step that already landed.
"Run it again" is often the costliest available mistake: a duplicate email or a double-charged invoice can beat the original failure.
1. **STOP**: pause the workflow and preserve current state.
2. **SCOPE**: identify which runs, clients, destinations, and time window were affected.
3. **RECONCILE**: for each item, determine whether the destination effect is confirmed, absent, ambiguous, or incorrect, _before_ any retry.
4. **RESUME**: restart only from the last verified checkpoint, using a destination-appropriate idempotency key, dedup rule, lookup, upsert, or compensating action.
5. **PROVE**: check the destination directly against acceptance criteria.
6. **LEARN**: document root cause, fix the control that let it happen, and update the runbook.
Temporal's documentation describes durable workflow state that persists through failures and resumes from where it left off, useful for step 4. For the retry mechanism, [Stripe's idempotent request documentation](https://docs.stripe.com/api/idempotent_requests) is concrete and vendor-specific: a matching-key retry returns the saved result, while mismatched parameters error. Other destinations need their own dedup or upsert logic.
> **At least once is not exactly once.** Most agent action paths guarantee a step was attempted at least once, not that it happened exactly once. Reconcile before you resume.
## What should you review in month three?
Month three is when a workflow's operating condition shows up, not demo quality, but schedule health, access hygiene, and output correctness.
The builder has usually moved on by now; assume it.
| Question | Evidence to inspect | Owner | Action if it fails |
| ----------------------------------------------------------------- | ----------------------------------------- | -------------- | ------------------------------------- |
| Is the schedule still firing as intended? | Run history, missed-run alerts | System owner | Fix trigger or reassign ownership |
| Are connectors and credentials still healthy and least-privilege? | Access review, credential age | System owner | Rotate, narrow scope, or revoke |
| Is context stale? | Sampled inputs vs. current reality | Workflow owner | Refresh source data or retire the run |
| Is output actually correct at the destination? | Sampled destination checks | Workflow owner | Add verification step or pause |
| Are exceptions being resolved or piling up? | Exception queue | Incident owner | Triage backlog; adjust thresholds |
| Is cost or latency per run reasonable? | Verified workflow records, not benchmarks | Business owner | Re-scope task or renegotiate approach |
| Can someone recover this without the original builder? | A recovery drill, run live | Incident owner | Rebuild the runbook; retrain |
| Is this workflow still worth running? | All of the above | Business owner | Continue, change, or decommission |
This is also where [AI workflows for agencies](/use-cases/agencies) matter for the consultant persona: the client relationship survives on a non-builder passing this review without a support call. Failing one check isn't a failed project. It's a decision for the owner.
## When do you need a workspace, a control plane, or both?
Match the requirement to the consequence: a bounded one-off task needs mostly execution; recurring work needs durable state; unattended work needs state plus real intervention.
| Workflow pattern | Workspace job | Execution job | Control job | Minimum proof before use |
| ----------------------------- | ------------------------------------------ | -------------------------------------------------------------------------------------------------- | --------------------------- | --------------------------------------- |
| One-off, supervised | Optional / bounded record | Required | Basic inspect + stop | A visible result you check yourself |
| Recurring team or client work | Durable state, artifacts, handoff material | Required | Approvals + inspection | Destination evidence plus a named owner |
| Consequential, unattended | Durable state, checkpoints, ownership | Bounded, recoverable. See [where to host AI agents](/blog/where-to-host-ai-agents) | Policy, intervention, audit | Reconciliation plus a recovery drill |
Real products land differently here. OpenAI describes its workspace agents as combining persistence and scheduled execution. The cited pages emphasize different jobs, and products may overlap: Microsoft Agent 365 centers on control-plane capabilities; AWS WorkSpaces centers on managed execution plus observation controls. None ranks above the others. The row above decides what you need, not the vendor's category.
Which tool builds the agent is a separate decision. See the [roundup of AI agent builders](/blog/6-best-ai-agent-builders-in-2026) if that's still open.
The useful Duet question is not "Does it replace every control plane?" It doesn't need to. Duet publishes its own agent-drive positioning, and that page is worth reading closely against the checklist above rather than taking it on faith. [Read Duet's agent-drive page](/) and check what it actually says: does it describe authoritative state, an execution boundary, approval controls, completion evidence, a named credential owner, a recovery checkpoint, and an export path, and does it frame each of those as shipped, in preview, or as direction? That question matters most to a consultant trying to leave behind more than a demo, with a recurring workflow, an owner, and a handoff path attached. Treat Duet the same way you'd treat any vendor named in this guide: one candidate to run through the matrix above, not a default answer, and not a substitute for checking these seven items yourself once you've picked a tool.
**Next action, in three steps:**
1. Write down which row above describes your actual workflow, not the demo version.
2. Name the four owners before the first production run.
3. Schedule the month-three review now, on a calendar.
Once the operating model is settled, [build an AI command center](/guides/how-to-build-your-ai-command-center) covers the practical setup. This article is about deciding what you need first.
## The bottom line
The demo is never the test. What decides whether an agent workflow survives is quieter than a polished walkthrough: does its state have a durable home, does someone own it by name, can you prove the work actually landed at the destination, and can a non-builder recover it when it breaks. Settle those four first, then match tools to the matrix above, not the other way around.
If you want that durable home to be one place instead of five scattered tabs and logins, Duet is worth running through the exact checklist you'd hold any vendor to: authoritative state, an execution boundary, approval controls, completion evidence, a named owner, a recovery checkpoint, and an export path. Name your four owners, put the month-three review on a calendar, and if Duet clears the checklist, [give your agents a workspace that outlasts the demo](https://app.duet.so/sign-in?from=blog-ai-agent-workspace-vs-control-surfaces).
## Frequently asked questions
### What is an AI agent workspace?
An AI agent workspace is a persistent environment where selected task state, context, files, permissions, schedules, outputs, and history remain available across sessions. It may also include execution and control capabilities, but the name alone doesn't prove them.
### What is the difference between an AI agent workspace and an agent control plane?
A workspace primarily gives work durable state and artifacts. A control plane provides governance, visibility, and intervention. One product may combine both, so compare implemented capabilities, not vendor labels.
### Do you need both a workspace and a control plane?
Not always. A low-risk supervised task needs only execution and basic controls. Recurring or consequential work usually needs durable state plus a way to approve, pause, and recover it, whether one product or several supplies those jobs.
### How do you manage AI agents after handing them to a client?
Document authoritative systems, schedules, permissions, approval rules, completion evidence, and four roles: business, workflow, system, incident owner. Then have a non-builder run and recover the workflow without calling the consultant.
### Can an AI agent keep working when your laptop is closed?
Yes, if execution and triggers run elsewhere. But laptop-independent execution alone does not prove durable state, correct outputs, safe retry, or client ownership. Verify what survives a restart and how the destination is reconciled.
### What evidence proves an AI agent finished a task?
Use destination-linked proof: a sent-message receipt and lookup, the updated CRM record, a deployment ID plus live smoke test, or a dated report tied to source inputs. The agent's own "done" message is only a claim.
---
Source: https://duet.so/blog/ai-agents-legacy-applications
# AI Agents for Legacy Applications: What Amazon WorkSpaces Actually Solves (and What It Doesn't)
*Amazon WorkSpaces lets AI agents click legacy apps. Here's what that solves, what it doesn't, and the decision framework for SMB operators.*
By Duet Team. Published 2026-07-18, updated 2026-07-18. 14 min read.
> Amazon WorkSpaces now lets an AI agent operate desktop applications that have no API — the unchanged software many small businesses still run every day. That solves reach: the agent gets a governed computer to click. It does not, by itself, solve continuity. A remote desktop is an execution surface; recurring work still needs a persistent home for files, context, approvals, run history, and ownership.
This is not about rewriting legacy code — it is about whether an AI agent can operate the desktop software you already run.
## What did Amazon WorkSpaces just change for legacy applications?
On June 30, 2026, AWS made [Amazon WorkSpaces for AI agents generally available](https://aws.amazon.com/about-aws/whats-new/2026/06/amazon-workspaces-ai/) — a governed computer an AI agent can see and click. It targets ERP systems, CRMs, mainframes, and proprietary tools AWS calls "too critical to abandon and costly to modernize."
The pitch is specific: an agent can operate existing desktop software "without requiring application modernization or custom integrations." Nothing about the underlying app changes to make this work.
AWS backs the launch with two stats from its own material. McKinsey, cited by AWS, puts 70% of the enterprise software Fortune 500 companies use at more than 20 years old. Gartner, cited by AWS, forecasts enterprises scaling past 150,000 agents by 2028, up from 15 in 2025.
Those numbers describe AWS's enterprise customers, not small businesses. But the condition they describe — recurring work stuck behind software with no API — isn't limited to companies that size. More on that below.
## Can an AI agent use my desktop applications?
Yes — with conditions. A computer-use agent perceives the screen through screenshots and acts through a virtual mouse and keyboard: the same screenshot-reason-act loop AWS itself uses to describe the capability.
[AWS's launch demo](https://aws.amazon.com/blogs/aws/modernize-your-workflows-amazon-workspaces-now-gives-ai-agents-their-own-desktop-preview/) shows what that looks like: a Strands Agent SDK agent completes a prescription refill — looks up the patient, searches the medication, places the order, confirms it — inside a sample pharmacy system with no API. "The application doesn't know an agent is driving it. Nothing about the software was modified, rebuilt, or integrated," AWS writes.
Two things worth being precise about. First, that's a demo AWS built on a sample system to illustrate the capability — not a published production case study. Second, reliability depends on UI stability, session length, and how explicit your instructions are; a stable, simple screen behaves very differently than a dense, dialog-heavy one.
## What does a remote desktop for AI agents actually give you?
It gives the agent an execution surface, not an operating home. That distinction is the pivot the rest of this article builds on.
**What the desktop session gives the agent:**
- Session control at three levels: watch only, watch-and-stop, or fully unattended
- Domain-joined identity, so actions attribute to an existing Active Directory account under existing access policies
- Tool forwarding, so MCP servers installed inside the session hand the agent direct tools instead of pixels wherever a programmatic interface exists
- A technical audit trail — logs, metrics, and screenshots via CloudTrail, CloudWatch, and S3
**What it does not give the work, by default:**
- A durable home for files
- Retained business context across sessions
- A workflow-approval gate before an external side effect
- A reviewable run history
- A named owner once the session ends
A desktop gives the agent reach. A persistent workspace gives the work continuity. That's the sentence worth carrying through the rest of this piece.
For where the agent's actual process should live — the server it runs on, not just the screen it clicks — see [where to host AI agents](/blog/where-to-host-ai-agents). AWS's own architecture makes the same hybrid bet: [route agents to tools where they exist and pixels where they don't](https://aws.amazon.com/blogs/desktop-and-application-streaming/amazon-workspaces-now-lets-ai-agents-operate-desktop-applications/).
## When should an agent use the screen instead of an API?
Structured APIs beat pixels on every measured axis where they exist. That's not an opinion — it's a controlled benchmark.
[Reflex ran the same task two ways](https://reflex.dev/blog/computer-use-is-45x-more-expensive-than-structured-apis/) on a react-admin "Posters Galore" demo panel seeded with 900 customers, 600 orders, and 324 reviews: once with a vision-based agent clicking through screenshots, once with the same Claude model calling the app's own API directly.
| Metric | Vision (screen) | API (structured) |
| -------------------------------- | ------------------------------ | ----------------------- |
| Input tokens | 550,976 ± 178,849 | 12,151 ± 27 |
| Wall-clock time | ≈17 min (1003s ± 254s) | ≈20s (19.7s ± 2.8s) |
| Steps / calls | 53 ± 13 steps | 8 ± 0 calls |
| Variance across 3 identical runs | 43–68 cycles, 407k–751k tokens | identical to ±27 tokens |
The gap is roughly 45×. The vision agent also initially failed the task outright — it found one of four pending reviews and stopped, with no signal to scroll for the rest — and only succeeded once given an explicit 14-step walkthrough naming every screen, tab, and field. Claude's cheapest model, Haiku, couldn't complete the vision path at all; on the API path it finished in 7.7 seconds using about 9,500 tokens, the cheapest configuration tested.
**Fair representation:** that 45× gap applies specifically where an API surface exists or can be generated. Reflex's own conclusion: "Vision agents remain the right tool for applications you do not control: third-party SaaS products, legacy systems, anything you cannot modify."
**That gap applies specifically where an API surface exists or can be generated.** Reflex says as much in its own conclusion: "Vision agents remain the right tool for applications you do not control: third-party SaaS products, legacy systems, anything you cannot modify." Both halves matter — the 45× figure isn't an argument that computer use is always wasteful. It's an argument for using it only where nothing better is available.
## Is this actually relevant to a small business, not just a Fortune 500 ERP?
AWS's own material is enterprise-framed — Fortune 500, Active Directory, claims processing, trade settlement. But the underlying pattern is measurably an SMB condition too.
A [2024 Intuit QuickBooks survey of 630 US small businesses](https://erp.intuit.com/blog/research/business-solutions-survey-2024/) with 10–99 employees found the average business runs 10 digital solutions and loses 25 hours a week to manual data entry and reconciliation across them. 43% named integration between apps as a direct challenge.
That gap shows up in the installed base itself. Intuit stopped selling new US subscriptions of QuickBooks Desktop Pro and Premier after September 30, 2024, but Desktop Enterprise is still sold today, and existing subscribers can keep renewing. Sage 100 is still actively positioned and sold to small and midsize businesses. The unchanged desktop software AWS is describing isn't hypothetical — it's what a lot of real operators run every day.
## What happens to the work when the laptop is closed?
Nothing continues on its own. A desktop session is ephemeral by design: no schedule, no run record, no handoff.
AWS makes its own version of this warning: an agent running straight off a laptop "inherits everything the laptop has — your operating system, your credentials, your network, your files," with "almost no line between the person and the autonomous worker."
Before you scale any workflow past a demo, it needs five things that don't come from the desktop session itself:
1. **Files** — a durable home for inputs and outputs
2. **Retained context** — what the agent learned last time, still true this time
3. **An approval gate** — a checkpoint before any external side effect
4. **Run history** — a reviewable record of what happened and when
5. **A named owner** — someone accountable once the builder moves on
If nothing in your setup answers "what happens overnight," you don't have a workflow yet — you have a demo. [Setting up a 24/7 AI agent that works while you sleep](/blog/how-to-set-up-a-24-7-ai-agent) covers the runtime side of that; [why your AI keeps forgetting (and how to fix it)](/guides/ai-amnesia-why-your-ai-keeps-forgetting) covers the memory side.
## Who owns the workflow after a consultant leaves?
Whoever inherits the context, credentials, artifacts, and run history — not whoever happened to be watching the agent's last session. Vendors sell session control, workflow approval, and handoff as one vague "human in the loop." Operators can't afford to collapse them.
| | What it means | Example |
| --------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------ |
| **Session control** | Interrupt a live run | Watch-and-stop: you halt the agent mid-task |
| **Workflow approval** | Review a proposed action before an external side effect | The invoice is drafted; you approve it before it posts |
| **Handoff** | Transfer context, credentials, artifacts, and run history to whoever inherits the workflow | The next person picks up exactly where the last one left off |
Picture a consultant running month-end close for five clients (an illustrative composite, not a named customer): each client's books live in a different desktop install. Watching a live session solves nothing if the review notes, approvals, and run log for each client don't survive the consultant's next vacation, or their next contract. [Who runs your AI agent after you build it](/blog/who-runs-your-ai-agent-after-you-build-it) walks through that ownership question in full.
## So which path should your business actually choose?
Three paths, stated fairly:
1. **Desktop-control runtime wins** for a true no-API GUI, a domain-joined identity requirement, or a strict compliance boundary you can't work around.
2. **API/integration-first wins** wherever a structured interface already exists — it wins on cost, latency, and determinism, per the benchmark above.
3. **Hybrid wins** for the common case: direct tools for the structured majority of a workflow, the screen only for the one irreducible step with no API. This is AWS's own GA architecture — MCP tool forwarding alongside computer use.
Before you scale any of the three, qualify the workflow:
- Pick one recurring workflow — for example, [invoice entry and reconciliation](/blog/how-to-automate-bookkeeping-financial-reporting-ai)
- Check every system it touches for an API, export, or database path
- Shrink the screen-control step to the smallest possible action
- Start supervised — watch-and-stop, not fully autonomous
- Define the one approval gate — the point of no return — before you loosen oversight
## Where does a persistent workspace like Duet fit into this?
A desktop-control runtime like Amazon WorkSpaces solves reach — it gives an agent a governed computer to click. It doesn't solve what happens between sessions, and it isn't meant to.
That's a different layer: a persistent workspace where an agent's files and memory outlive any single session, where scheduled runs keep recurring work moving without an open laptop, and where outputs land as real, shareable artifacts instead of screen recordings. Duet is one example of that layer. It holds durable shared memory across every agent on a team — what one agent learns about your pricing rules or customer history, the next one already knows. It runs pipelines and scheduled work on their own clock. It hosts dashboards and internal tools at real URLs. And nothing external ever sends or posts without your explicit approval first.
None of that requires WorkSpaces, and none of it operates a legacy application's screen. It's the ledger the desktop session doesn't keep. [Map one recurring workflow against it](/) — the files it touches, the approval it needs, who owns it after handoff — and see what's actually missing.
---
A desktop gives the agent reach. A persistent workspace gives the work continuity. WorkSpaces answers the first question well. Before you build on it, answer the second one too: map one recurring workflow — the app it touches, the files it reads and writes, the approval before any side effect, the run history you'd need to show someone, and who owns it after handoff.
## Frequently asked questions
**What is an AI agent desktop?**
A phrase used loosely for a computer or virtual machine an AI agent can see and operate — usually via screenshots and simulated mouse and keyboard input. Amazon WorkSpaces for AI agents and [Microsoft Copilot Studio's computer-use tool](https://learn.microsoft.com/en-us/microsoft-copilot-studio/computer-use) are two governed, vendor-backed versions of the idea; "AI agent desktop" isn't a single product.
**Can AI agents really operate legacy software that has no API?**
Yes. As of Amazon WorkSpaces' June 30, 2026 general availability, an agent can be given a governed desktop session and interact with any application that renders on screen — no API required. AWS's own demo shows an agent completing a prescription refill in a sample pharmacy system without modifying the application. Reliability still depends on UI stability, session length, and how explicit your instructions are.
**Is computer use the same thing as RPA?**
No. RPA runs deterministic scripts against fixed selectors and breaks when the UI changes. Computer-use agents perceive the screen and reason about what to click, so they adapt to layout changes — but that reasoning is probabilistic, slower, and far more token-hungry per step than either RPA or a direct API call.
**How much more expensive is computer use than an API integration?**
In one controlled Reflex benchmark on an identical admin-panel task, the vision-based agent used 550,976 input tokens and took about 17 minutes; the same task through a structured API took 12,151 tokens and about 20 seconds — roughly a 45× gap, with the API path also showing zero run-to-run variance. That gap applies specifically where an API surface exists or can be generated; for a genuinely no-API legacy system, screen control remains the only option.
**Do I need Amazon WorkSpaces (or AWS at all) to automate a legacy application?**
No. AWS is the vendor behind this specific launch and the clearest current example of a governed desktop-control runtime, but it isn't the only path — Microsoft's Copilot Studio ships a comparable computer-use tool for Windows automation. The decision that matters is architectural (desktop control vs. API-first vs. hybrid), not which cloud you're already on.
**Does Duet integrate with Amazon WorkSpaces or operate my desktop apps directly?**
No. Duet has no computer-use or remote-desktop product, and no integration or partnership with Amazon WorkSpaces exists. Duet is a persistent workspace — durable files, memory, schedules, and approvals — that a desktop-control runtime like WorkSpaces could feed into, as a complementary layer, not a bundled product.
**What's the safest way to start automating a no-API legacy workflow?**
Pick one recurring workflow and map every system it touches. Route anything with an API or export path through direct integrations. Shrink the screen-control step to the smallest possible action. Start supervised — watch-and-stop, not fully autonomous — and define the one approval gate, the point of no return, before you loosen oversight.
---
Source: https://duet.so/blog/ai-automation-agency-guide
# AI Automation Agency Guide: Build, Deploy, and Run Client Agents
*A practical AI automation agency guide to scoping client agents, choosing runtime ownership, operating responsibly, improving the system, and planning a clean handoff.*
By Duet Team. Published 2026-07-17, updated 2026-07-17. 16 min read.
An AI automation agency is a consultant or agency practice that delivers AI-enabled workflows or agents for a defined client business job. Doing this responsibly means deciding, in advance, who owns deployment, day-to-day operation, ongoing improvement, and the eventual handoff or retirement — not just shipping a working build.
A build is a project with a start and a finish line. A running client agent is an operating commitment with no natural end date — it reads data, sends messages, or takes actions on someone's behalf every day the contract is in force. The gap between those two things is where most agency engagements either become a credible service or quietly turn into a mess nobody agreed to.
Picture a small appliance-repair business. A boutique agency builds it a client agent that reads inbound quote requests, checks technician availability, drafts a reply with a proposed appointment window, and books the confirmed job. The demo works beautifully in a sandbox with ten sample emails. The question this guide actually answers is what happens on day 30, when a request looks nothing like the ten samples, a technician's calendar API changes its response format, or the client asks for a feature nobody scoped. That example is illustrative only — not a case study, not an outcome claim — but it's concrete enough to carry the whole argument.
## What is an AI automation agency, and what happens the moment a build goes live?
An AI automation agency delivers AI-enabled workflows or agents around a defined client business job, and its delivery model has to name who owns deployment, operation, improvement, and the exit path once that system is live. Think of these as five decisions a consultant makes across the life of an engagement — **Build → Deploy → Operate → Improve → Transfer / Retire** — a practical **Duet editorial synthesis**, not an industry, NIST, Anthropic, or Google standard.
"Live" is not a synonym for "done." A client agent that sends its first real message is a system someone now has to watch, someone has to be reachable when it misfires, and someone has to decide what changes and what doesn't. If none of that is written down, the agency hasn't shipped a service — it's shipped a liability with a demo attached. This is also where **AI automation agency services** earns its meaning: the word "services" only means something if the agency can point to a bounded set of responsibilities it has actually agreed to carry, not just an invoice for software access.
| Stage | Core consultant decision | Evidence of completion | What must not be assumed |
| --------------------- | ----------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| **Build** | Define the business job, system behavior, tool boundaries, approval points, and representative tests. | The agreed version handles representative cases in a controlled setting. | That an agent is even needed, or that a build is production-ready. |
| **Deploy** | Choose runtime/account ownership, configure access and dependencies, define launch approval and a pause/rollback route. | A production owner, access path, launch criteria, and change path exist on paper. | That launch closes out the engagement. |
| **Operate** | Name review, triage, incident communication, and context-upkeep responsibilities. | A written operating boundary exists and both sides have seen it. | That monitoring catches every problem, or implies any coverage promise. |
| **Improve** | Test and release agreed changes to instructions, context, tools, permissions, workflows, or models. | Evaluations and approvals are recorded before consequential changes ship. | That every change is low-risk or immune to regression. |
| **Transfer / Retire** | Hand over or retire agreed assets, schedules, access, and responsibilities. | The client accepts the transfer; agency access is removed as agreed. | That handing over source code is a complete handoff. |
Every later section in this guide is really an elaboration of one row in that table.
## What should an agency actually build — and when is an agent overkill?
Start with a specific business job, decide what stays human-owned, and pick the smallest system that fits it: a predictable workflow is often the right call for well-defined tasks, and an agent earns its complexity when the work genuinely needs flexible, model-directed decisions. That second half matters more than it sounds — plenty of "agent" projects are workflows wearing a mask, and plenty of genuine agents get built for jobs that never needed the extra unpredictability.
Before writing a single prompt, a consultant can answer six questions in plain language: Who is this for? What triggers it? What does a good output look like? What result is unacceptable? What tools or actions is it allowed to touch? And where's the human approval point? Add a short set of representative test cases — normal, edge, refusal — and the build phase has an actual finish line instead of a vibe. Going back to the repair-shop example: the trigger is an inbound message, the tools are a calendar lookup and a draft-reply action, the unacceptable result is booking a slot the technician doesn't actually have, and the approval point might be a human glance before the first message ever sends to a real customer.
[Anthropic's guide to building effective agents](https://www.anthropic.com/engineering/building-effective-agents) makes this same case from the engineering side: start with the simplest solution that meets the use case, treat predictable workflows as the default for well-defined work, and reserve agents — with tools, retrieval, and memory layered on — for cases that need more flexible, model-directed judgment. Anthropic also flags that autonomous agents can compound errors and cost, which is exactly why they recommend real sandbox testing and guardrails before anything touches production. None of that is a guarantee that any specific build is ready; it's a reason to earn the complexity rather than default to it.
Once the business job and its boundaries are clear, the packaging question — what the agency actually sells as a first offer — is worth working through on its own: [Package Your Expertise Into an AI Agent](/blog/package-your-expertise-into-an-ai-agent).
## What actually changes the moment a build deploys?
Deployment is the move from a tested build into an intended production arrangement, and it forces explicit answers about account ownership, access, dependencies, launch approval, and a way to pause or roll back. It is not evidence that the agency can now walk away.
This is the point where a lot of engagements quietly lose their shape. The build phase has a natural checkpoint — the demo either works or it doesn't. Deployment doesn't have that same clean signal, because the system that looked finished in a sandbox is now touching a live inbox, a real calendar, or an actual customer conversation, and every one of those integrations is a place where responsibility has to land on somebody by name. [NIST's Generative AI Profile](https://nvlpubs.nist.gov/nistpubs/ai/NIST.AI.600-1.pdf) lists post-deployment monitoring, incident response, recovery, change management, and decommissioning among the risk-management considerations worth planning for — voluntary guidance, not a certification, and nothing here should be read as a claim that any deployment is "NIST compliant." What it's useful for is a checklist of the categories a consultant should have an answer to before flipping the switch, even if the answer for a small engagement is intentionally lightweight.
## Should the client or the agency own the runtime and the accounts?
There's no default winner here: client-owned, agency-managed, and hybrid arrangements each trade off differently across control, access, billing, portability, client capacity, and who's actually accountable when something goes wrong.
| Arrangement | Who owns the production account/runtime? | Useful when | Responsibility to make explicit | Trade-off to name |
| ------------------ | ---------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| **Client-owned** | The client holds provider accounts, billing, and admin control; the agency gets scoped access. | The client wants direct control, has internal technical ownership, or cares about continuity after the engagement ends. | Admin owner, access grant/revocation, vendor notices, change authority, succession. | More coordination overhead; client-side changes can break the live system without warning. |
| **Agency-managed** | The agency runs the production environment and grants the client agreed visibility and approvals. | The agency is deliberately selling managed operation and the exit terms are written down. | Client separation, access, billing transparency, response ownership, portability, departure. | The agency now carries real operational weight; shared infrastructure must not blur data or privileges between clients. |
| **Hybrid** | The client keeps high-consequence systems and core accounts; the agency operates an agreed runtime layer on top. | The client wants control boundaries but doesn't have day-to-day operating capacity. | Alert ownership, billing, permissions, approval rights, handoff sequence. | Split ownership creates gaps unless the seam between the two sides is documented. |
Six questions cut through most of the ambiguity here: What can the agent actually read, write, or send? Which of its actions carry real consequences if they go wrong? Who holds the provider contracts and pays the bill? Who could operate this without the agency in the room? What has to move at offboarding? And who can approve — or pause — a production change? If an agency runs multiple clients on shared infrastructure, tenant isolation stops being an assumption and becomes a design decision; [AWS's guidance on tenant isolation](https://docs.aws.amazon.com/wellarchitected/latest/saas-lens/tenant-isolation.html) treats this as foundational for shared SaaS, with the actual implementation depending on domain, compliance needs, and architecture — a general consideration, not proof that any particular agency setup is isolated or secure.
The deeper mechanics of where and how to actually host a client agent are their own subject: [Where to Host AI Agents](/blog/where-to-host-ai-agents).
## What does "operating" an agent actually require once it's live?
A managed client agent needs a written runbook naming what gets checked, who owns the response and the client conversation, what's allowed to change, how context stays current, and exactly where the agency's responsibility stops.
That runbook doesn't need to read like a compliance document to be useful. Ten things belong in it: the service definition and its explicit non-goals; named owners on both sides plus an escalation contact; an inventory of assets and dependencies; the access and revocation path; launch acceptance criteria and a pause/rollback route; the signals actually reviewed, on what cadence, and the limits of that monitoring; an incident lead, client communication route, working record, and containment path; the change classes allowed, their tests, approvals, and rollback; the authoritative sources for context and who owns keeping them current; and an offboarding inventory. For the repair-shop agent, that might mean: someone checks failed bookings and escalated messages daily, the technician's manager is the incident contact, and a double-booked slot triggers an immediate pause on new confirmations until it's fixed.
Say this plainly to clients, because it's true: monitoring only covers the signals you define and act on — it is not a reliability guarantee. [Google's incident-response guidance](https://sre.google/workbook/incident-response/) separates fixing the technical problem from managing the response itself — coordination, communication, a clear lead, a working record — and that split is worth borrowing even for a two-person shop. It doesn't require a large-company command structure or an SLA to be useful; it just requires naming, in advance, who does what when something breaks.
Naming that structure is also what turns "we'll keep an eye on it" into a service someone can actually be accountable for: [Who Runs Your AI Agent After You Build It?](/blog/who-runs-your-ai-agent-after-you-build-it)
## How do you change a live agent without losing control of it?
Treat every change to prompts, context, tools, permissions, workflows, or the underlying model as a change to a live service: test it against representative cases, run it through the agreed approval path, record what shipped, and keep a way to roll it back.
Four change classes make this easier to reason about: an operational correction (fixing something that's clearly broken), a behavior or content change (adjusting tone, scope, or output style), a capability or permission change (giving the agent new tools or wider access), and emergency containment — pause the schedule, revoke a connection, disable a tool, roll back a release, and sort out the root cause afterward. Context sources, instructions, and tool descriptions are maintained dependencies, not a one-time training pass; the repair-shop agent's understanding of "which technicians work Saturdays" will drift the moment the client changes staffing, and nobody will tell the agent unless someone owns that update. OpenAI's evals guidance is useful here in spirit: keep a small, representative test set for the business job and rerun it before consequential changes ship — that discipline catches regressions, though it never guarantees quality, safety, or reliability on its own.
Permissions deserve the same discipline: give agent actions the smallest set of permissions that actually does the job, keep a revocation path within reach, and put genuinely high-impact actions — sending money, deleting records, messaging a client's entire list — behind an approval step. [OWASP's prompt-injection guidance](https://genai.owasp.org/llmrisk/llm01-prompt-injection/) describes how both direct and indirect prompt injection can arise, including from content the agent merely reads, and recommends constrained behavior and least privilege to reduce the blast radius. It does not claim a foolproof fix, and neither should anyone using it as a reference.
## When does this become a real recurring service instead of vague maintenance?
A recurring service is credible when it names actual continuing work — defined review, incident triage, approved changes, context upkeep, documentation, or reporting — rather than folding every post-launch request into a catch-all called "maintenance."
Scope grows or shrinks based on a handful of real variables: how many workflows are live and how critical each one is, how sensitive the data and integrations are, who owns the runtime, how often anyone actually reviews the system, how much change is allowed without a new conversation, and how much documentation or reporting the client expects. What sits inside that scope should be explicit, and so should what doesn't: new integrations, expanded permissions, net-new features, provider costs, data migration, a formal security or compliance review, round-the-clock coverage, and any recovery-time commitment are all separate conversations, not line items buried in a flat monthly fee.
Turning that boundary into an actual retainer — what to charge for it, how to package it — is a distinct question worth its own answer: [Turn AI Agent Builds Into Recurring Retainers](/blog/turn-ai-agent-builds-into-recurring-retainers).
## How do you end an engagement cleanly?
A clean exit deliberately transfers or ends the operating responsibility: inventory the assets, reassign or revoke access, transition or disable schedules, document who the final owner is, and get the client's acknowledgment as agreed.
Code is the smallest part of a real handoff. What actually needs to move includes the instructions and context sources, the workflow or configuration itself, the evaluation/test cases built up over the engagement, account and integration settings, the schedule and trigger inventory, documentation, and credentials or authorizations. Skip any of those and the client inherits a system they can't actually run — which is its own kind of failure, even if the original build worked perfectly. The specifics of data handling, deletion, retention, and what the contract actually requires depend entirely on the engagement; nothing here should be read as legal, compliance, privacy, or security advice.
Before selecting any runtime or workspace to help run all of this, write down the operating boundary first: who owns the accounts, what gets reviewed, who approves changes, and how the client eventually takes the system over or retires it. That sequencing — boundary first, tooling second — is the difference between choosing infrastructure that fits a real commitment and choosing infrastructure that just looks capable in a sales call.
## Frequently asked questions
### What is an AI automation agency?
It's a consultant or agency practice built around delivering AI-enabled workflows or agents for a client's specific business job — and stopping there isn't enough. The delivery model also has to spell out who owns deployment, day-to-day operation, ongoing improvement, and the eventual handoff or retirement, so "it works in the demo" never gets mistaken for "the engagement is done."
### What services does an AI automation agency provide?
Services can include defining a business job, building a workflow or agent that fits it, deploying it into an agreed runtime and account arrangement, and — only where explicitly agreed — operating, improving, documenting, and eventually transferring that system. The scope should name the actual work rather than hiding behind the word "maintenance."
### Is an AI agent always better than a workflow?
No. Anthropic recommends starting with the simplest solution that fits the use case: workflows tend to suit well-defined, predictable tasks, while agents fit work that genuinely needs flexible, model-directed decisions. The right choice follows the client's job, the actions it's allowed to take, and how much review it needs — not a default preference for the more sophisticated option.
### Should the agency or the client own the AI agent runtime?
Neither is automatically correct. Compare client-owned, agency-managed, and hybrid arrangements against control, access, billing, portability, the client's own capacity, and which party is actually prepared to own the consequences after launch.
### What should be included in an AI agent operations runbook?
A useful runbook names the service boundary, the owners and escalation contact on each side, the assets and dependencies involved, the access and revocation path, launch acceptance criteria, the signals actually reviewed, the incident communication process, change controls, how context stays current, and the offboarding plan. It should fit the engagement, not double as a guarantee or a certification.
### How can an AI automation consultant offer a recurring service without vague maintenance?
Anchor the offer to work that's actually happening on a schedule — a review cadence, an incident-triage process, an approval path for changes, someone keeping context current, and a reporting rhythm the client can see. Whatever isn't included should be said out loud, not discovered later: new integrations, added capabilities, wider permissions, and promises like round-the-clock coverage all deserve their own conversation and their own scope.
---
Source: https://duet.so/blog/automate-dropshipping-product-research-ai
# How to Automate Dropshipping Product Research with AI
*Stop manually checking AliExpress and TikTok. Build an automated AI agent pipeline to find, score, and alert you of winning dropshipping products.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 13 min read.
Most dropshippers lose hours every week doing product research the hard way — tabs open across AliExpress, Jungle Scout, TikTok trends, and competitor stores, trying to manually piece together whether a product is actually worth testing. By the time you've done the research, the window's often already closing.
AI changes that equation completely. Instead of manually scanning for winning products, you can set up an AI agent that does it for you — continuously, on a schedule, against your exact criteria. This guide walks through how to automate dropshipping product research with AI: what to track, which tools to use, how to set it up without engineering skills, and how to know when a product the AI finds is actually worth your ad spend.
**Quick Summary**
This guide shows how to automate dropshipping product research using AI agents — scanning for trending products, checking supplier ratings, and surfacing high-margin opportunities without manual browsing of AliExpress or Jungle Scout.
**Questions this page answers**
- How to automate dropshipping product research with AI
- Best AI tools for dropshipping product research
- How to find winning dropshipping products using AI
- Can AI replace manual dropshipping research?
- How to set up automated product research for dropshipping
## Manual Product Research a Losing Strategy
Manual product research cannot keep pace with how fast trends move across platforms. By the time you spot a trending product through browsing, automated sellers have already listed it, run ads, and captured early demand.
The numbers tell the story:
- **92% of new dropshippers** struggle to find profitable products consistently
- Manual research takes **4-6 hours per day** across multiple platforms
- Trending products on TikTok peak in **7-14 days** — manual discovery misses the window
- AI-powered stores achieve **3.5x higher conversion rates** compared to manually curated catalogs
Products chosen through AI-assisted research are **50% more likely to become bestsellers** within 90 days. Not because AI is magic — because it processes more data points faster than any human can.
The average product lifespan before market saturation sits around **60 months**. But viral products saturate in weeks. Timing is the entire game, and manual processes are structurally too slow.
## Automated Product Research System
An automated product research system has five stages: data collection, normalization, AI analysis, scoring, and alerting. Each stage feeds the next without human intervention.
**System architecture:**
| Stage | Tool | Output |
| --------------- | --------------- | ----------------------- |
| Data Collection | Firecrawl | Raw product listings |
| Normalization | Python/Claude | Structured JSON |
| Scoring | Claude API | 0-100 score per product |
| Storage | JSON/SQLite | Product database |
| Delivery | Email/Dashboard | Morning briefing |
The key data sources for dropshipping product research:
- **AliExpress:** Trending products, order volumes, supplier ratings
- **Amazon Movers & Shakers:** 24-hour sales velocity changes
- **TikTok Creative Center:** Viral product hashtags and ad performance
- **Google Trends:** Search demand trajectory
- **CamelCamelCamel / Keepa:** Historical pricing data
For the scraping fundamentals behind this system, see [How to Scrape, Analyze, and Monitor Any Website Automatically](/blog/how-to-scrape-analyze-and-monitor-any-website).
## Build a Product Scraper for Dropshipping
Start with Firecrawl to scrape each data source, then normalize the output into a unified product schema. Three scrapers cover the highest-signal sources.
### Scrape AliExpress Trending Products
Use Firecrawl's scrape endpoint against AliExpress category pages. Target the "Top Selling" and "Weekly Trending" sections.
```plaintext
const scrapeTrending = async category => {
const response = await firecrawl.scrape({
url: `https://www.aliexpress.com/popular/${category}.html`,
formats: ['markdown'],
onlyMainContent: true,
})
const products = await ai.extract({
content: response.markdown,
schema: {
name: 'string',
price: 'number',
orders: 'number',
rating: 'number',
shippingDays: 'number',
storeYears: 'number',
},
})
return products
}
```
Run this across 8-12 categories relevant to your niche. Each scrape returns 20-50 products. Store everything in a JSON file or lightweight database.
### Scrape Amazon Movers & Shakers
Amazon's Movers & Shakers page shows products with the largest 24-hour sales rank improvements — a direct proxy for demand spikes.
```plaintext
const scrapeAmazonMovers = async department => {
const response = await firecrawl.scrape({
url: `https://www.amazon.com/gp/movers-and-shakers/${department}`,
formats: ['markdown'],
waitFor: 3000, // Allow dynamic content to load
})
return ai.extract({
content: response.markdown,
schema: {
name: 'string',
currentRank: 'number',
previousRank: 'number',
percentChange: 'number',
price: 'number',
reviewCount: 'number',
},
})
}
```
Products that jump 500+ rank positions in 24 hours are strong signals. Cross-reference these against AliExpress availability.
### Track TikTok Viral Products
Scrape TikTok's Creative Center for trending hashtags related to product categories. Focus on hashtags with high view velocity (views gained in the last 7 days).
```plaintext
const trendingHashtags = ['tiktokmademebuyit', 'amazonfinds', 'dropshipping2026', 'viralproducts']
const scrapeTikTokTrends = async () => {
const results = []
for (const tag of trendingHashtags) {
const data = await firecrawl.scrape({
url: `https://ads.tiktok.com/business/creativecenter/hashtag/${tag}`,
formats: ['markdown'],
})
results.push({ hashtag: tag, content: data.markdown })
}
return results
}
```
For deeper scraping strategies and handling anti-bot measures, check [How to Scrape, Analyze, and Monitor Any Website](/blog/how-to-scrape-analyze-and-monitor-any-website).
## Using AI to Analyze and Score Products
Feed the normalized product data to an AI model with a structured scoring prompt that evaluates four dimensions: demand signals, competition level, margin potential, and trend velocity.
### The Scoring Framework
| Category | Weight | What It Measures |
| ----------------- | ------ | -------------------------- |
| Demand Velocity | 35% | Search trend acceleration |
| Margin Potential | 30% | Price vs. AliExpress cost |
| Competition Level | 20% | Competitor store count |
| Trend Longevity | 15% | Sustained vs. viral demand |
Each product gets scored 0-100 across four weighted categories:
### The Scoring Prompt
```plaintext
const scoreProduct = async product => {
const prompt = `Analyze this product for dropshipping potential.
Score each dimension 0-25. Be specific about why.
Product: ${JSON.stringify(product)}
Return JSON:
{
"demandScore": number,
"demandReason": "string",
"competitionScore": number,
"competitionReason": "string",
"marginScore": number,
"marginReason": "string",
"trendScore": number,
"trendReason": "string",
"totalScore": number,
"recommendation": "STRONG_BUY | BUY | WATCH | SKIP",
"riskFactors": ["string"]
}`
return ai.generate(prompt)
}
```
Products scoring 75+ are worth immediate action. Products in the 60-74 range go on a watch list. Below 60, skip.
Dynamic pricing tools that adjust based on these scores can increase margins by **23%** on average. For a full breakdown of AI-driven market analysis, see [How to Use AI for Market Research Before Launch](/blog/how-to-use-ai-for-market-research-before-launch).
## Set Up Cron Jobs for Automated Scans
Schedule the entire pipeline to run at 6:00 AM daily using a cron job, so a scored product briefing lands in your inbox before you start work.
### Create the Pipeline Script
Combine the scraping and scoring steps into a single executable:
```plaintext
// pipeline.js
const runDailyPipeline = async () => {
// 1. Scrape all sources
const aliProducts = await scrapeTrending('electronics')
const amazonMovers = await scrapeAmazonMovers('electronics')
const tiktokTrends = await scrapeTikTokTrends()
// 2. Normalize and deduplicate
const allProducts = normalize([...aliProducts, ...amazonMovers, ...tiktokTrends])
// 3. Score each product
const scored = await Promise.all(allProducts.map(scoreProduct))
// 4. Sort by total score
const ranked = scored.sort((a, b) => b.totalScore - a.totalScore)
// 5. Generate briefing
const briefing = generateBriefing(ranked.slice(0, 15))
// 6. Send via email/Slack
await sendBriefing(briefing)
// 7. Archive results
await saveToDatabase(ranked)
}
```
### Schedule the Cron
```plaintext
# Run daily at 6:00 AM
0 6 * * * node /path/to/pipeline.js >> /var/log/product-research.log 2>&1
```
### Configure the Briefing Format
Your morning email should include:
- **Top 5 products** with scores, prices, and one-line rationale
- **New entries** that appeared since yesterday
- **Movers** — products whose scores changed significantly
- **Dropped products** that fell below threshold
For the full setup guide on scheduled AI tasks, see [How to Set Up a 24/7 AI Agent](/blog/how-to-set-up-a-24-7-ai-agent).
## Build a Dashboard to Visualize Product Opportunities
Build a web dashboard that displays your scored product pipeline, trends, and category performance. Four panels cover it:
1. **Today's Top Products** — Ranked list with scores, prices, and trend indicators
1. **Score History** — Line chart showing how top products' scores change over days
1. **Category Heatmap** — Which niches are heating up or cooling down
1. **Supplier Tracker** — AliExpress supplier reliability scores and shipping times
```plaintext
```
The dashboard reads from the same JSON database your cron job writes to. No backend needed — a static site with client-side JavaScript works fine.
For a walkthrough on building and deploying dashboards like this, see [How to Build and Deploy a Web App Using Only AI](/blog/how-to-build-and-deploy-a-web-app-using-only-ai).
## Finding a Winning Product Actually
A real comparison: manual vs. automated pipeline on the same day, targeting home organization.
**Manual process (4 hours 47 minutes):**
1. Browse AliExpress "Home Organization" — 45 min
1. Check Amazon Best Sellers in Storage — 30 min
1. Search TikTok for #homeorganization — 40 min
1. Google Trends comparison of 6 products — 25 min
1. Check competitor stores for pricing — 50 min
1. Calculate margins on a spreadsheet — 35 min
1. Read supplier reviews — 40 min
1. Final decision: magnetic spice rack organizer
**Automated pipeline (14 minutes):**
1. Open morning email briefing — 2 min
1. Review top 15 scored products — 5 min
1. Click through to 3 highest-scored products, verify data — 5 min
1. Order samples from top pick — 2 min
1. Final decision: same magnetic spice rack organizer (scored 87/100)
Same conclusion. One-fifteenth of the time. The pipeline also flagged two products the manual search missed — a collapsible kitchen strainer (score: 82) and a cable management clip set (score: 79) — both with strong TikTok velocity that hadn't hit Amazon's bestseller lists yet.
Full automation enables managing operations with **57% fewer employees** while handling **3.2x more products**.
## Pipeline Break Without a Persistent Server
The system described above works — until your laptop sleeps, your IP gets rate-limited, or you forget to run it for a week.
Scrapers need to run on schedule regardless of whether your machine is on. They need rotating IPs to avoid blocks. The AI scoring step requires API calls that take 10-20 minutes for 200+ products. And the dashboard needs to be accessible from your phone, not just your dev machine.
A cloud-hosted AI agent server solves this. The scraper runs on a persistent machine, cron jobs fire reliably, and results are available from any device. [Duet](/) is one option that bundles the AI runtime, cron scheduling, web scraping via Firecrawl, and app hosting in a single environment — so the pipeline, dashboard, and alerting all run from one server without stitching together five services.
In practice: your scraper runs at 4 AM, AI scoring finishes by 5:30 AM, and the briefing hits your inbox at 6 AM. Every day. Whether you're at your desk or asleep.
For monitoring competitor pricing alongside product research, see [Dropshipping Price Monitor with AI Alerts](/blog/dropshipping-price-monitor-ai-alerts).
## Common Product Research Automation Mistakes
Avoid these five mistakes that kill most automated product research systems:
1. **Scraping too infrequently.** Weekly scrapes miss fast-moving trends entirely. Daily is the minimum for dropshipping. Hourly for viral product categories.
1. **No deduplication logic.** The same product appears across AliExpress, Amazon, and TikTok with different names. Without fuzzy matching, your pipeline scores it three times and skews results.
1. **Ignoring shipping costs in margin calculations.** A product with 70% markup on paper becomes 15% after $8 ePacket shipping and returns. Always factor in landed cost.
1. **Over-relying on a single data source.** AliExpress order counts can be manipulated. Amazon rankings fluctuate by hour. TikTok virality is fleeting. Cross-platform confirmation is what produces reliable signals.
1. **Not tracking what you skip.** Products you pass on today might spike next week. Log every scored product so you can backtest your scoring model and improve it over time.
For tracking suppliers alongside products, see [Find Dropshipping Suppliers with AI and Web Scraping](/blog/find-dropshipping-suppliers-ai-web-scraping). For competitive monitoring beyond product research, see [How to Automate Competitive Intelligence for Your Startup](/blog/how-to-automate-competitive-intelligence-startup).
## Frequently Asked Questions
### How much does it cost to run an automated product research pipeline?
Firecrawl's standard plan costs $83/month for 3,000 scrape credits. AI scoring with Claude or GPT-4 runs $15-30/month depending on volume. Server hosting adds $10-25/month. Total: roughly **$110-140/month** — less than the hourly cost of a VA doing the same work for 20 hours per week at $5/hour ($400/month).
### Can I scrape AliExpress without getting blocked?
Yes, but you need rotating proxies or a managed scraping service like Firecrawl that handles IP rotation and CAPTCHA solving. Direct scraping from a single IP gets blocked within 50-100 requests. Rate-limit your scraper to 1 request per 3-5 seconds and rotate user agents.
### What AI model works best for product scoring?
Claude and GPT-4 both produce reliable scoring when given structured prompts with clear criteria. The model matters less than the prompt design and data quality. A well-structured prompt with Claude Haiku at $0.25/million tokens outperforms a vague prompt with Opus at $15/million tokens.
### How many products should the pipeline evaluate daily?
Target **150-300 products per day** across all sources. Fewer than 100 and you miss opportunities. More than 500 and AI scoring costs climb without proportional improvement. The top 10-15 products from a 200-product scan are statistically similar to the top 10-15 from a 1,000-product scan.
### Does this work for print-on-demand or only traditional dropshipping?
The pipeline works for any product research — print-on-demand, traditional dropshipping, private label, or wholesale. Adjust the data sources: for POD, add Etsy trending and Merch Informer data. For private label, add Jungle Scout or Helium 10 exports. The scoring framework stays the same.
### How long before I see results from automated product research?
Most sellers report finding their first profitable product within **2-3 weeks** of running the pipeline daily. The system improves over time as you tune the scoring weights based on actual sales data. By month three, your hit rate on winning products should be 2-3x what manual research produces.
### Can I use free tools instead of paid scraping services?
You can start with Python + BeautifulSoup + free proxy lists. Expect 10-15 hours building the scraper and frequent breakage from anti-bot updates. Paid services save roughly 20 hours/month in maintenance. Start free to learn, then migrate to paid tools once the pipeline generates ROI.
---
Source: https://duet.so/blog/claude-code-hooks
# Top 10 Claude Code Hooks to Use in 2026
*Copy-paste 10 Claude Code hooks into your settings.json today. Auto-format files, block destructive commands, get notifications, enforce git workflows, and more.*
By Duet Team. Published 2026-05-29. 16 min read.
Claude Code ships with a hook system that most developers never touch.
That's a mistake. Hooks are shell commands that fire automatically at specific points in Claude Code's workflow -- before a tool runs, after a file is written, when a task finishes. They turn a generic AI coding assistant into _your_ AI coding assistant.
This guide gives you 10 hooks you can copy-paste into your `.claude/settings.json` today. No custom tooling, no complex setup. Each one solves a real problem that slows down AI-assisted development.
## What are Claude Code Hooks?
Claude Code hooks are shell commands that execute automatically during specific events in Claude Code's lifecycle. Think of them as git hooks, but for your AI coding assistant instead of your version control system.
Without hooks, Claude Code is powerful but generic. It writes code, runs commands, and edits files -- but it does all of this the same way for every developer on every project.
Hooks let you customize that behavior at the system level:
- Auto-format every file the moment it's written, so you never commit messy code
- Block destructive commands like `rm -rf` or `DROP TABLE` before they execute
- Get a desktop notification when a long-running task finishes
- Log every change Claude makes to a file for audit trails
- Inject project-specific context automatically at session start
Hooks are defined in your settings file and run as standard shell scripts. If you can write a bash one-liner, you can write a hook.
## How Claude Code Hooks Work
Hooks fire at four points in Claude Code's execution lifecycle. Understanding these events is the key to writing hooks that work.
**PreToolUse** fires before any tool executes. Your hook receives the tool name and its input as JSON on stdin. This is where you intercept and block -- exit code 0 means proceed, exit code 2 blocks the tool call entirely. Use this for security gates, validation, and anything where prevention beats cleanup.
**PostToolUse** fires after a tool finishes. Your hook receives the tool name, input, and output. This is the workhorse event -- auto-formatting, logging, notifications, and follow-up actions all live here. Exit code doesn't block anything at this stage; the tool already ran.
**Notification** fires when Claude Code sends a notification (typically when a task completes or needs attention). Good for routing alerts to Slack, Discord, or your preferred notification channel.
**Stop** fires when Claude Code completes a response and stops executing. Useful for session-end cleanup, summary generation, or triggering downstream workflows.
Every hook receives context as JSON on stdin. The shape depends on the event type, but it always includes the tool name and relevant input/output data. You parse it with `jq`, process it however you want, and exit with the appropriate code.
Here's the anatomy of a hook definition in `.claude/settings.json`:
```json
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"command": "./scripts/my-hook.sh"
}
]
}
}
```
The `matcher` field is optional. If omitted, the hook fires on every tool call for that event type. If specified, it filters by tool name -- and it's case-sensitive, so `"Bash"` won't match `"bash"`.
## 10 Claude Code Hooks to Steal
Every hook below includes the `settings.json` config and a brief explanation of what it does. Copy the ones that fit your workflow.
### 1. Desktop notifications for completed tasks
You kick off a long task, switch to Slack or your browser, and forget to check back. Ten minutes later you realize Claude finished ages ago.
This hook fires a native desktop notification whenever Claude Code sends a notification event. On macOS it uses `osascript`, on Linux it uses `notify-send`.
```json
{
"hooks": {
"Notification": [
{
"command": "if command -v osascript &>/dev/null; then osascript -e 'display notification \"Task complete\" with title \"Claude Code\"'; elif command -v notify-send &>/dev/null; then notify-send 'Claude Code' 'Task complete'; fi"
}
]
}
}
```
This is the single most useful hook for anyone who multitasks while Claude works. Set it once, forget about it.
### 2. Destructive command blocker
Claude occasionally runs commands that can cause real damage -- `rm -rf` on the wrong directory, `DROP TABLE` in production, `git push --force` to main. By the time you notice, it's too late.
This `PreToolUse` hook intercepts Bash commands and blocks anything matching a list of dangerous patterns. Exit code 2 stops the command cold.
```json
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"command": "DANGEROUS='rm -rf|DROP TABLE|git push.*--force|git reset --hard|mkfs|dd if=|:(){ :|:& };:'; CMD=$(cat | jq -r '.tool_input.command // empty'); if echo \"$CMD\" | grep -qEi \"$DANGEROUS\"; then echo \"BLOCKED: Destructive command detected\" >&2; exit 2; fi"
}
]
}
}
```
You can customize the `DANGEROUS` pattern list to match your environment. Add database-specific commands, deployment scripts, or anything else that shouldn't run without explicit human approval.
### 3. Auto-formatter on file write
Claude writes functional code, but it doesn't always match your project's formatting rules. You end up with a noisy diff full of whitespace changes mixed in with actual logic changes.
This `PostToolUse` hook detects when Claude writes or edits a file, then runs your formatter on it automatically. It supports Prettier for JS/TS, Black for Python, and gofmt for Go -- add whatever formatters your project uses.
```json
{
"hooks": {
"PostToolUse": [
{
"matcher": "Write|Edit",
"command": "FILE=$(cat | jq -r '.tool_input.file_path // empty'); if [ -n \"$FILE\" ]; then case \"$FILE\" in *.js|*.ts|*.jsx|*.tsx) npx prettier --write \"$FILE\" 2>/dev/null;; *.py) black --quiet \"$FILE\" 2>/dev/null;; *.go) gofmt -w \"$FILE\" 2>/dev/null;; esac; fi"
}
]
}
}
```
The beauty of this hook is that it's invisible. Files are formatted the instant they're written, so every diff you review is clean.
### 4. Sensitive file protector
Claude can read and edit any file in your project. That includes `.env` files, credentials, private keys, and other files that should never be modified by an AI assistant.
This `PreToolUse` hook blocks Write and Edit operations on files matching sensitive patterns. It checks the file path against a list of protected patterns and exits with code 2 if there's a match.
```json
{
"hooks": {
"PreToolUse": [
{
"matcher": "Write|Edit",
"command": "PROTECTED='\\.env|\\.env\\\\.|credentials|secrets|private.key|id_rsa|\\.pem$'; FILE=$(cat | jq -r '.tool_input.file_path // empty'); if echo \"$FILE\" | grep -qEi \"$PROTECTED\"; then echo \"BLOCKED: Cannot modify sensitive file: $FILE\" >&2; exit 2; fi"
}
]
}
}
```
Pair this with the destructive command blocker for a solid security baseline. Between the two, you've covered the most common ways an AI assistant can accidentally cause damage.
### 5. Git branch enforcer
Claude doesn't know your branching strategy. It might commit directly to main, push to a protected branch, or create commits on the wrong branch entirely.
This hook checks the current git branch before any Bash command runs. If you're on main or master, it blocks the operation and tells Claude to switch branches first.
```json
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"command": "CMD=$(cat | jq -r '.tool_input.command // empty'); if echo \"$CMD\" | grep -qE 'git (commit|push|merge)'; then BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null); if [ \"$BRANCH\" = 'main' ] || [ \"$BRANCH\" = 'master' ]; then echo \"BLOCKED: Cannot commit/push to $BRANCH. Switch to a feature branch first.\" >&2; exit 2; fi; fi"
}
]
}
}
```
This is especially useful in teams where pushing to main requires a PR. The hook enforces the workflow at the tool level, before git's own branch protections even come into play.
### 6. Auto-linter on file save
Formatting is one thing, but linting catches actual code quality issues -- unused variables, missing imports, type errors. Claude doesn't always run your linter after writing code.
This `PostToolUse` hook runs ESLint (or your linter of choice) on every file Claude writes or edits. If the linter finds issues, the output goes to stderr so Claude can see them and fix them in the next step.
```json
{
"hooks": {
"PostToolUse": [
{
"matcher": "Write|Edit",
"command": "FILE=$(cat | jq -r '.tool_input.file_path // empty'); if [ -n \"$FILE\" ]; then case \"$FILE\" in *.js|*.ts|*.jsx|*.tsx) npx eslint --fix \"$FILE\" 2>&1;; *.py) ruff check --fix \"$FILE\" 2>&1;; esac; fi"
}
]
}
}
```
Stack this with the auto-formatter hook. Run the formatter first (for whitespace), then the linter (for logic). Order matters -- put the formatter hook before the linter hook in your settings array.
### 7. Change logger and audit trail
When Claude modifies dozens of files across a session, it's hard to track what changed, when, and why. Git diff helps after the fact, but a real-time log is better for debugging.
This `PostToolUse` hook logs every file write and edit to a timestamped log file. It captures the file path, the tool used, and the timestamp so you can reconstruct exactly what happened during a session.
```json
{
"hooks": {
"PostToolUse": [
{
"matcher": "Write|Edit|Bash",
"command": "INPUT=$(cat); TOOL=$(echo $INPUT | jq -r '.tool_name // empty'); FILE=$(echo $INPUT | jq -r '.tool_input.file_path // .tool_input.command // empty'); echo \"[$(date -Iseconds)] $TOOL: $FILE\" >> /tmp/claude-audit.log"
}
]
}
}
```
For production use, replace `/tmp/claude-audit.log` with a path inside your project directory (and gitignore it). You can also extend this to log to a remote service or append the git diff for each changed file.
### 8. Context injector
Every new Claude Code session starts cold. Claude doesn't know your project's conventions, architecture decisions, or current sprint goals unless you tell it every time.
This hook injects project context at session start by reading from a context file and passing it to Claude as part of the tool input. You maintain a single `CONTEXT.md` file with your project's key decisions, and the hook ensures Claude always has it.
```json
{
"hooks": {
"PreToolUse": [
{
"command": "if [ -f \"$CLAUDE_PROJECT_DIR/.claude/CONTEXT.md\" ]; then echo \"Project context: $(cat $CLAUDE_PROJECT_DIR/.claude/CONTEXT.md)\" >&2; fi"
}
]
}
}
```
Keep your `CONTEXT.md` concise -- architecture decisions, naming conventions, key dependencies, and current priorities. Claude reads it on every tool call, so shorter is better.
### 9. Test runner on code changes
Claude writes code that looks correct but breaks existing tests. You don't find out until you manually run the test suite, by which point Claude has moved on to the next task.
This `PostToolUse` hook runs relevant tests whenever Claude modifies a source file. It detects the corresponding test file by convention (`foo.ts` -> `foo.test.ts`) and runs just that file's tests, keeping feedback fast and targeted.
```json
{
"hooks": {
"PostToolUse": [
{
"matcher": "Write|Edit",
"command": "FILE=$(cat | jq -r '.tool_input.file_path // empty'); if [ -n \"$FILE\" ] && echo \"$FILE\" | grep -qE '\\.(ts|js|py)$' && ! echo \"$FILE\" | grep -qE '\\.(test|spec)\\.'; then TEST=$(echo \"$FILE\" | sed 's/\\.(ts|js|py)$/.test.\\1/'); if [ -f \"$TEST\" ]; then npx jest \"$TEST\" --no-coverage 2>&1 | tail -5; fi; fi"
}
]
}
}
```
The `tail -5` at the end keeps the output short. Claude sees the pass/fail summary without getting flooded by verbose test output. If tests fail, it can read the full output by running the test command itself.
### 10. Slack/Discord notification on task completion
Desktop notifications work when you're at your computer, but what about when you step away? Or when you want your whole team to see that a task finished?
This hook sends a message to a Slack or Discord webhook whenever Claude Code completes a task. It uses the `Stop` event so it only fires once per response, not on every tool call.
```json
{
"hooks": {
"Stop": [
{
"command": "curl -s -X POST -H 'Content-type: application/json' --data '{\"text\":\"Claude Code task completed in '\"$CLAUDE_PROJECT_DIR\"'\"}' $SLACK_WEBHOOK_URL"
}
]
}
}
```
Set `SLACK_WEBHOOK_URL` in your shell environment (not in the hook config, to keep the webhook URL out of version control). For Discord, swap the payload format to match Discord's webhook API -- the structure is nearly identical.
## How to Debug Failing Hooks
Hooks fail silently by default. Claude Code won't throw an error if your hook never runs -- it just moves on. Here's how to track down what's going wrong.
**Hook not firing at all.** Open the `/hooks` menu in Claude Code and verify three things: the event type matches what you expect, the matcher string is case-sensitive (a matcher for `"Bash"` won't catch `"bash"`), and the hook is actually enabled. Most "broken" hooks are just misconfigured matchers.
**Hook fires but errors appear in the transcript.** Isolate the problem by running the hook manually. Pipe sample JSON into your script and check the exit code:
```bash
echo '{"tool_name":"Bash","tool_input":{"command":"ls"}}' | ./your-hook.sh && echo $?
```
If this works in your terminal but fails in Claude Code, your shell profile is likely the culprit. `.bashrc` or `.zshrc` might print welcome messages or run commands that corrupt the JSON stream. Guard any output with `[[ $- == *i* ]]` so it only runs in interactive shells.
**Need the full picture?** Run `claude --debug-file /tmp/claude.log` to capture detailed execution traces, including hook invocations and their exit codes. The `/hooks` browser also gives you a read-only view of all registered hooks and their current state.
## Hooks Best Practices
A few principles that'll save you from debugging hooks at 2am.
**Keep hooks fast.** Default timeout is 600s but hooks block execution. Aim for under 1 second. If you need to do something slow -- posting to Slack, running a linter on a large codebase -- fire it async. Background the process, write to a log, and move on.
**Exit code 2 is your friend.** It's the only code that blocks. Exit 1 is a non-blocking error -- this trips people up. Unless you're building a security gate (like blocking destructive commands), default to exit code 0.
**Fail open, not closed.** If your hook script errors, Claude continues. Design for this. A hook that returns exit code 2 on an unexpected error will block all matched tool calls until you figure out what broke. Reserve exit code 2 for intentional blocks.
**Use jq for input parsing.** Every hook receives JSON on stdin. `jq -r '.tool_input.file_path'` is the standard pattern. Don't try to parse JSON with grep or sed.
**One hook, one job.** It's tempting to build a mega-hook that lints, logs, and notifies. Don't. Separate hooks are easier to debug, easier to disable, and easier to share with your team. Compose behavior by stacking multiple hooks on the same event.
**Test outside Claude Code first.** Pipe realistic JSON through your hook script before registering it. Edge cases like tool inputs with special characters, newlines in commands, or missing fields will surface immediately.
## How to Share Hooks Across a Team
Hooks become powerful when the whole team runs them. The key is `.claude/settings.json` -- it's project-scoped, lives in your repo, and applies to everyone who clones it.
Commit your hook scripts to `.claude/hooks/` and reference them with relative paths in the settings file. When a new developer pulls the repo, they get every guardrail automatically. No setup docs, no onboarding checklist, no "oh you need to install the pre-commit hook."
For hooks that are personal preference -- desktop notifications, custom formatters -- use `~/.claude/settings.json` instead. That's user-scoped and won't pollute the team config. `.claude/settings.local.json` is gitignored by default for exactly this purpose.
For enterprise teams, managed policy settings allow org-wide enforcement. You can also package hooks as a reusable plugin with `hooks/hooks.json`. And use `$CLAUDE_PROJECT_DIR` in your scripts for portable paths that work regardless of where the repo is cloned.
## Epilogue
Hooks turn Claude Code from a chat-with-an-AI experience into something closer to a real development environment -- one with guardrails, automation, and team-wide consistency.
Start small. Pick one or two hooks from this list that solve a real friction point in your workflow. The destructive command blocker and auto-formatter are the easiest wins. Once those are running, layer in logging, notifications, or context injection as you find new pain points.
The full hook system is more capable than what we've covered here. Custom matchers, chained scripts, and enterprise policy enforcement open up workflows we haven't even touched. But the 10 hooks above will handle 90% of what most teams need.
Grab the configs, drop them in your `.claude/settings.json`, and ship.
## Frequently Asked Questions
Hooks are shell commands that run automatically at specific points in Claude Code's workflow.
You define them in your settings file with an event type (like PreToolUse or PostToolUse), an
optional matcher to target specific tools, and the command to execute. When Claude Code hits a
matching event, it pipes context as JSON to your script's stdin and uses the exit code to decide
what happens next -- 0 to proceed, 2 to block, 1 to warn but continue.
It depends on your workflow, but the 10 hooks covered in this guide are a strong starting point.
The most universally useful are the destructive command blocker (saves you from accidental rm
-rf), auto-formatting on file write, and desktop notifications for long-running tasks. Start
with one or two, then layer in more as you find friction points.
Add a Notification hook in your .claude/settings.json with no matcher (so it fires on
everything), and point it at a script that calls notify-send on Linux or osascript on Mac. The
full recipe with cross-platform detection is in hook #1 above.
Check three things: the matcher is case-sensitive ("Bash" won't match "bash"), the event type is
correct (PreToolUse vs PostToolUse), and the hook is registered in the right settings file. Open
/hooks in Claude Code for a read-only view of all registered hooks.
Yes. If your hook script exits with code 2, Claude Code will stop the matched tool call
entirely. This is how the destructive command blocker and sensitive file protector work. Exit
code 0 means proceed, exit code 1 logs a warning but doesn't block.
They can if you're not careful. Hooks run synchronously, so a slow script adds latency to every
matched tool call. Keep hooks under one second. If you need to do something expensive like
posting to an API, background the process and exit immediately.
Commit your hook scripts to .claude/hooks/ in your repo and define them in
.claude/settings.json, which is project-scoped. Every developer who clones the repo gets the
same hooks automatically. Personal-preference hooks go in ~/.claude/settings.json so they don't
affect the team.
---
Source: https://duet.so/blog/claude-code-mobile-iphone-android
# Best Way to Access Claude Code on Mobile in 2026
*Learn how to use Claude Code from your phone. Duet's iOS and Android apps let you check agents, tweak prompts, and ship code from anywhere, no desktop required.*
By Duet Team. Published 2026-06-16, updated 2026-06-16. 8 min read.
Claude Code workflows don't have to stop when you leave your desk.
With Duet's native iOS and Android app, you can stay connected to the agents running on your personal server, checking progress, making quick edits, and even shipping work, all from your phone.
This guide shows exactly how Duet turns "I'll finish that later at my laptop" into "done from the couch."
Whether you're a founder checking on an overnight agent run, a developer tweaking a prompt between meetings, or someone who simply wants more flexibility, the mobile Claude Code experience is now practical, reliable, and built for real life.
---
## Claude Code on Mobile
### How Duet Makes It Possible
Claude Code workflows have traditionally lived on a laptop.
You open a terminal, keep a session alive, and stay near your desk.
Duet changes the equation by giving every user a personal server where agents run 24/7, plus native iOS and Android apps that let you stay in the loop from anywhere.
Instead of trying to squeeze a full coding environment onto a phone, Duet keeps the heavy lifting on the server and surfaces just what you need: agent status, prompt editing, approvals, and output review. Open the Duet app on your iPhone or Android device, tap into an active agent, and you can:
- Check whether it's still running or waiting for input
- Tweak the prompt or instructions on the fly
- Approve the next step or ship the final result
No SSH, no VPN, no "I'll finish this when I get back to my laptop." The desktop experience stays richer for long-form coding, but the mobile apps remove the hard requirement to be at your desk for the check-in, quick-edit, and ship moments.
This is the practical mobile Claude Code workflow Duet enables today.
---
## The Mobile Workflow for Claude Code
Duet's mobile experience is built around three lightweight moments that keep your Claude Code agents moving even when you're away from your desk.
### Check-In
Open the Duet app and you'll see a list of your active agents. Each card shows status at a glance — running, waiting for input, or completed. Tap any agent to view its current task, recent output, and how long it's been working. No need to remember what you kicked off last night; the app surfaces the context instantly.
### Quick-Edit
Found an issue or want to steer the agent in a new direction? Tap the prompt or instructions section and make your change directly in the app. The updated instructions are sent to the server immediately, so the agent picks up the new guidance on its next step. This is perfect for course-correcting mid-run without firing up a laptop.
### Ship
When the agent finishes or reaches a decision point, you'll get a notification. Review the output in the app, approve the final result, or trigger the next action, all without leaving the couch. For many workflows, the entire review-and-ship cycle happens on your phone.
These three interactions, check-in, quick-edit, ship, are the core of Duet's mobile Claude Code workflow. They don't replace deep desktop coding sessions, but they remove the friction of "I can't touch this until I'm back at my desk."
---
## iOS App Walkthrough
On iPhone, Duet's native app keeps the full agent experience in your pocket. After signing in with your Duet account, you'll land on a clean dashboard showing every active agent and its current status.
Tapping an agent opens a detailed view with:
- Real-time status indicator (running, paused, waiting)
- The current prompt or task description
- Scrollable output log so you can review what the agent has already produced
- Inline editing for the prompt or instructions
When an agent needs input or finishes a step, iOS push notifications surface the update. Tap the notification to jump straight into the agent view, no extra navigation required.
The app also supports quick actions from the lock screen or Notification Center for common moves like "approve and continue" or "pause agent." For deeper reviews, the full editing and approval flow lives inside the app, designed for one-handed use on the go.
Everything syncs instantly with your personal server, so changes made on iPhone appear immediately on desktop or Android.
---
## Android App Walkthrough
The Android experience mirrors iOS with the same core workflow, optimized for Android's notification and widget system.
After signing in, the home screen shows your active agents with live status chips. Tapping any agent opens the full detail view, where you can:
- Read the current prompt and output history
- Edit instructions inline and save instantly
- Approve, pause, or trigger the next step with one tap
Android notifications are particularly useful here, they appear in the notification shade and on the lock screen, and support quick reply-style actions for common approvals. Widgets can also surface agent status on your home screen if you want at-a-glance visibility without opening the app.
Like iOS, every action syncs in real time with your Duet server, so the desktop and mobile views stay in lockstep.
---
## Duet Desktop vs Mobile
Duet's mobile apps don't replace the desktop experience, they complement it. Knowing when to reach for your phone versus your laptop keeps you productive without forcing every task into the smaller screen.
### Use Mobile When You Need
- **Quick status checks:** See if an overnight agent finished or is still running without opening a laptop.
- **Light prompt tweaks:** Fix a typo, adjust a constraint, or add a missing detail while you're on the move.
- **Approvals and shipping:** Review output and give the green light from anywhere. Notifications and one-tap actions make this frictionless.
- **Between-meeting or couch moments:** Short, focused interactions that don't require deep context or heavy editing.
### Stick to Desktop When You Need
- **Long-form prompt engineering:** Writing or refactoring complex multi-step instructions is faster and more accurate on a full keyboard.
- **Deep code review:** Reading large diffs, comparing outputs, or debugging detailed results is easier with more screen real estate.
- **Multi-agent orchestration:** Managing several agents in parallel or building new workflows from scratch benefits from the richer desktop interface.
- **Heavy collaboration:** Sharing detailed context, commenting on specific lines, or pairing with teammates is smoother on a larger screen.
The pattern most Duet users settle into is simple: desktop for creation and deep work, mobile for momentum. You start a complex Claude Code run on your laptop, then use the iOS or Android app to keep it moving throughout the day. When the agent hits a decision point or finishes, the phone is enough to review and ship, no context switch required.
This split keeps you in flow without the old "everything waits until I'm back at my desk" bottleneck.
---
## Frequently Asked Questions
### Is there a Claude Code iPhone app?
Not a standalone one, but Duet's native iOS app gives you full control over your Claude Code agents. Open the app, tap any running agent, and you can check status, edit prompts, or ship results without touching a laptop.
### Is there a Claude Code Android app?
Same story on Android. Duet's Android app mirrors the iOS experience, so you get the same real-time agent visibility, inline editing, and one-tap approvals whether you're on an iPhone or Pixel.
### How do I use Claude Code from my phone?
Use Duet. Your agents run 24/7 on a personal server. When you're away from your desk, open the Duet app, check which agents are active, tweak a prompt if needed, and approve or ship the output. It's the same Claude Code workflow, just reachable from anywhere.
### Does Duet replace my desktop Claude Code setup?
No. The heavy prompt engineering and deep reviews still happen on a laptop. The mobile apps handle the in-between moments, status checks, quick fixes, and final approvals, so nothing stalls while you're out.
### Do I need to keep the Duet app open for agents to run?
Not at all. The agents live on the server. The app is just your window into them. Close it completely and the work continues; notifications bring you back in when there's something to review.
### Can I start a new Claude Code agent from my phone?
Complex runs are best started from desktop, but Duet's mobile apps let you trigger saved workflows or quick agents on the go. For anything multi-step or high-stakes, setting it up on a bigger screen first is still the better call.
---
Source: https://duet.so/blog/claude-code-pricing
# Claude Code Pricing in 2026: Plans, Token Costs, and the Cloud Option
*How much does Claude Code cost? Claude Pro is $20/mo, Claude Max is $100–$200/mo, plus API token costs, the cloud option, and a full plan comparison for 2026.*
By Duet Team. Published 2026-04-24, updated 2026-07-20. 24 min read.
## Claude Code pricing at a glance (2026)
| Plan | Price | Best for |
| ----------------------- | -------------------------------------- | ------------------------------------ |
| **Claude Pro** | **$20 / month** | Solo dev, occasional Claude Code use |
| **Claude Max 5x** | **$100 / month** | Daily user hitting Pro rate limits |
| **Claude Max 20x** | **$200 / month** | Claude Code as primary IDE, all day |
| **Team Premium** | **$100 / seat / month** (5-seat min) | Small teams that want SSO + admin |
| **Anthropic API** | **Pay-per-token** ($1–$25 / 1M tokens) | Agencies, per-client cost tracking |
| **Run it in the cloud** | **Monthly managed plan** | Async / 24-7 runs without a desktop |
**Or run it in the cloud on a monthly plan** — [Duet](/pricing) hosts Claude Code in a persistent sandbox. Included credits reset at renewal, and the paid reserve covers overage during a heavy shipping month.
The rest of this page goes deep on each tier: what the rate limits actually mean, where the hidden extra-usage trap lives in API mode, and which plan fits a solo dev vs a team of five vs an agency running Claude Code across a dozen client codebases.
By the end, you'll know exactly what Claude Code will cost _you_, not some hypothetical power user, and which plan to pick.
**TL;DR**
Claude Code ships under four pricing models: Pro at $20/month, Max 5x at $100 and Max 20x at $200, API pay-as-you-go ($1 to $25 per million tokens), and Team Premium seats at $100/seat with a 5-seat minimum. The right answer depends on how much you use it, whether you're solo or on a team, and how much billing predictability you need.
- Solo dev under 50M tokens/month: Claude Pro at $20. Don't overthink.
- Claude Code is your primary IDE: Max 20x at $200. Stop fighting rate limits.
- Team of 3 to 10 with uneven usage: a managed platform with pooled usage like Duet beats $100/seat Team Premium math.
- Agency with bursty client work: Duet for predictability, API for pure per-client cost tracking.
## Claude Code Pro vs Max vs API usage
Claude Code has three pricing models that look similar on the surface but behave very differently in practice. Pick the wrong one and you'll either hit a wall mid-afternoon or pay two to three times what you needed to.
### Subscription plans (Claude Pro and Claude Max)
This is the most common entry point. You pay a flat monthly fee and get a token allowance that resets on a 5-hour rolling window, with a weekly ceiling layered on top. There are three tiers:
- **Claude Pro: $20/month.** Access to Sonnet 4.6 and Opus 4.7, roughly 44,000 tokens per 5-hour window, and about 40 to 80 hours of Sonnet use per week. Enough for focused coding sessions, not enough for all-day Claude Code as your primary IDE.
- **Claude Max 5x: $100/month.** Around 88,000 tokens per 5-hour window and 140 to 280 hours of Sonnet plus 15 to 35 hours of Opus per week. Built for developers who were hitting Pro limits daily.
- **Claude Max 20x: $200/month.** Roughly 220,000 tokens per 5-hour window, 240 to 480 hours of Sonnet, and 24 to 40 hours of Opus weekly. This is the tier where rate limits stop interrupting your day.
One important detail: your usage limit is shared across Claude.ai chat and Claude Code. If you burn tokens chatting with Claude in the browser, that eats into the same bucket Claude Code draws from.
### Claude Code API pricing
Instead of a subscription, you can pay per token through the Anthropic API. Claude Code will authenticate with an API key and bill you based on what you actually use.
Current rates:
- Opus 4.7: $5 per million input tokens, $25 per million output tokens
- Sonnet 4.6: $3 input, $15 output per million tokens
- Haiku 4.5: $1 input, $5 output per million tokens
- Prompt caching: 5-minute cache writes cost 1.25x the input rate, 1-hour cache writes cost 2x, cache reads cost 0.1x
One thing to watch: Opus 4.7 ships with a new tokenizer that can produce up to 35% more tokens for the same input text compared to Opus 4.6. The per-token rate is unchanged, but your effective cost per prompt may be higher simply because the same code gets tokenized into more pieces.
API billing is precise but unpredictable. Heavy Opus usage on a large codebase can easily run $30 to $60 per day. That's the flexibility tax.
### Claude Code team plans and Enterprise
For groups, Anthropic offers Team plans starting at $20/seat/month on Standard, but Claude Code is only included on Premium seats at $100/seat/month (annual billing) or $125/seat/month (monthly billing), with a minimum of 5 seats. You can mix Standard and Premium seats on the same team.
Enterprise unlocks a 500K context window, HIPAA readiness, SSO, custom data retention, and custom pricing through Anthropic sales. It's the right fit if compliance or procurement is in the room.
### The new "extra usage" wrinkle
In 2026, Anthropic added an "extra usage" toggle on every paid consumer plan. When you hit your included limit, instead of stopping cold, you can opt in to continue at standard API rates with a monthly spend cap you control.
This matters more than it sounds. It turns the Pro vs Max decision from "which ceiling do I want" into "which baseline do I want, and how much overflow am I comfortable paying for."
### The trap everyone falls into
If you have an `ANTHROPIC_API_KEY` environment variable set on your machine, Claude Code will silently use the API key instead of your Pro or Max subscription.
You'll keep getting billed through the API while your $200/month Max plan sits there unused.
Check your shell profile before you pay for a subscription. This is the single most common Claude Code pricing mistake we see.
## Claude Code pricing comparison
This is the table to bookmark. Every plan Anthropic sells, plus the API option and where a managed platform fits, laid out so you can see the real trade-offs in one glance.
| Plan | Price | Models | 5-hr window | Weekly limit (Sonnet) | Weekly limit (Opus) | Best for |
| ----------------------- | ---------------------------------- | -------------------- | ----------------------- | ----------------------- | ----------------------- | ----------------------------------------------------------------- |
| **Claude Pro** | $20/mo | Sonnet 4.6, Opus 4.7 | ~44K tokens | 40–80 hrs | Limited | Solo devs, side projects, a few focused hours/day |
| **Claude Max 5x** | $100/mo | Sonnet 4.6, Opus 4.7 | ~88K tokens | 140–280 hrs | 15–35 hrs | Daily Claude Code users hitting Pro limits weekly |
| **Claude Max 20x** | $200/mo | Sonnet 4.6, Opus 4.7 | ~220K tokens | 240–480 hrs | 24–40 hrs | Full-day Claude Code workflows, large repos |
| **Team (Premium)** | $100/seat/mo (annual), min 5 seats | Sonnet 4.6, Opus 4.7 | Per-seat Max-equivalent | Per seat | Per seat | Teams of 5+ with centralized billing |
| **Enterprise** | Custom | All + 500K context | Custom | Custom | Custom | Compliance, SSO, HIPAA, procurement |
| **API (pay-as-you-go)** | $3–25 per M tokens | All models | No cap | No cap | No cap | Unpredictable or very low usage, automation |
| **Duet** | Starter, Pro, or Max monthly plan | Claude (managed) | Shared monthly credits | Reserve covers overage | No per-seat bucket | Teams who want managed cloud + shared access |
### More about the table
**Price column.** Max 5x and Max 20x aren't "better Pro." They're bigger buckets. The ceiling gets higher, the model access stays the same.
**5-hour window.** This is the rolling budget. Every prompt costs tokens; tokens reset 5 hours after your first request of a session. Miss this and you'll think Claude Code "broke" at 3pm.
**Weekly limits.** Added in August 2025 to stop 24/7 background usage. Most users never hit them. Power users running Claude Code across multiple repos all week can.
**Models.** Pro, Max, and Team all get the same Claude models. What differs is how much you can use them.
**Opus vs Sonnet.** Opus is the expensive, smarter model. On Max plans you get a separate weekly allowance for Opus on top of Sonnet. On Pro, Opus access is limited enough that most Pro users default to Sonnet.
### Which Claude Code plan fits which buyer?
- **Hobbyist, student, occasional user.** Claude Pro. You will not out-use $20/month.
- **Working developer coding 4 to 6 hours/day.** Pro with extra usage enabled, or Max 5x if you hit the wall weekly.
- **Claude Code is your primary IDE.** Max 20x. Stop fighting the limits.
- **Team of 5+ with one invoice.** Team Premium seats, or a managed platform with flat pricing.
- **Agency with bursty, variable workloads.** API for bursts, or Duet for predictability.
- **Healthcare, finance, regulated.** Enterprise, no shortcuts.
### Where the comparison table lies a little
Two asterisks worth knowing:
1. **"Tokens per 5-hour window"** is Anthropic's estimate based on average usage. Large codebases burn tokens 3 to 5x faster than average because every file you load eats context. A 200K-line monorepo on Pro will hit limits long before "44K tokens" suggests.
2. **Team seats** require a 5-seat minimum. A 3-person startup doesn't have a clean Anthropic option. You're either buying 5 seats and wasting 2, or stacking individual Max subscriptions and losing centralized billing.
This is where Claude Code pricing stops being a table and starts being a decision. The next section walks through four real scenarios with actual monthly numbers.
## Claude Code cost scenarios
Sticker prices lie. What matters is what hits your card at the end of the month once you account for how you actually work. Here are four honest scenarios with real numbers.
### The solo developer (side project + day job)
**Profile.** Full-time job, ships a side project on nights and weekends. Uses Claude Code 1 to 2 hours a day, mostly Sonnet, occasional Opus for hard bugs.
**Estimated monthly usage.** ~25M tokens.
**Cost breakdown:**
- **Pro ($20/mo).** Fits comfortably, maybe 2 to 3 "you've hit your limit" moments per month. Best choice.
- **Max 5x ($100/mo).** Overkill. You'd use 20% of the allowance.
- **API pay-as-you-go.** ~$40 to $60/mo at Sonnet rates. More expensive than Pro and less predictable.
**Verdict.** Pro at $20/month. Turn on extra usage as a safety net.
### The full-time Claude Code user
**Profile.** Developer who's gone all-in on Claude Code as their primary IDE. 6 to 8 hours a day, large repo, heavy Opus usage for architecture work.
**Estimated monthly usage.** ~300M tokens.
**Cost breakdown:**
- **Pro ($20/mo).** You'll hit the 5-hour wall before lunch. Don't.
- **Max 5x ($100/mo).** Workable most days. You'll hit weekly Opus limits by Friday.
- **Max 20x ($200/mo).** Rate limits stop being a factor. This is the tier built for you.
- **API pay-as-you-go.** Roughly $800 to $1,500/mo at this volume. One developer case study showed $15,000 in API charges over 8 months vs ~$800 on Max. A 93% swing.
**Verdict.** Max 20x at $200/month. The math isn't close.
### The team of 5
**Profile.** Five-person engineering team, all using Claude Code daily, mix of Sonnet and Opus, one AP person who wants a single invoice.
**Estimated monthly usage.** Varies per dev; 3 heavy, 2 light.
**Cost breakdown:**
| Option | Monthly cost | Notes |
| -------------------------------- | --------------- | ------------------------------------------------------------- |
| 5× individual Max 5x | $500 | No central billing, no admin controls, reimbursement headache |
| 5× individual Max 20x | $1,000 | Same problem, more expensive |
| Anthropic Team (5 Premium seats) | $500 | Centralized billing, but 2 light users are overpaying |
| Mix: 3 Premium + 2 Standard | $380 | Only if the 2 light users don't need Claude Code at all |
| Managed platform (Duet) | Flat team price | Unlimited seats, shared access, predictable monthly |
If every engineer codes with Claude daily, Team Premium at $500/mo is fine. If usage is uneven, which it almost always is, a managed platform with flat pricing avoids paying $100/seat for someone who uses Claude Code twice a week.
### The agency
**Profile.** Eight developers rotating across a dozen client codebases, highly bursty (all-hands-on-deck during sprint weeks, quiet between). Needs shared access, not per-seat math.
**Estimated monthly usage.** 500M+ tokens, spiky.
**Cost breakdown:**
- **8× Max 20x.** $1,600/mo. Overpays in quiet weeks, still rate-limited per account during bursts.
- **Anthropic Team (8 Premium).** $800/mo. Better, but per-seat allowances don't pool. One developer can hit limits while another's bucket sits idle.
- **API pay-as-you-go.** $2,000 to $4,000/mo at this volume, fully variable. Great for cost tracking per client, brutal for cash flow.
- **Duet (managed, team plan).** Monthly credits are shared across the workspace; the paid reserve covers overage without per-seat ceilings.
Agencies are where "predictable monthly + pooled usage" beats per-seat Anthropic pricing almost every time. Either Duet or an Enterprise conversation with Anthropic.
### The pattern
Look across all four scenarios and one thing stands out: Anthropic's direct pricing is optimized for the **individual power user** (Max 20x is genuinely a bargain at 300M+ tokens).
It gets awkward for **teams with uneven usage** and **agencies with bursty workloads**, because per-seat allowances don't pool and Team pricing assumes everyone uses it equally.
That's the gap managed platforms fill. More on that two sections down.
## Hidden Claude Code costs to watch (tokens, context windows, MCP calls)
The sticker price is only half the story. What makes Claude Code pricing genuinely hard to predict are the mechanics underneath, the things that quietly multiply your token burn without showing up on the plan comparison page. Here are the four that trip people up most often.
### Context window tax
Every time Claude Code reads a file, that file stays in the context window for the rest of the conversation. Ask Claude to "look at the auth module" in a big repo and you might load 40,000 tokens before you've typed a single real prompt. Every subsequent message re-sends that context.
The practical effect: a 30-minute session on a large codebase can burn 300K to 500K tokens even if you only sent 10 messages. On Pro, that's a meaningful chunk of your 5-hour allowance gone before lunch. On the API, that's real dollars. A long Opus session can quietly cost $15 to $25.
**What to do.** Use `/clear` between unrelated tasks. Avoid loading entire directories when a single file will do. If you're on Pro and hitting limits fast, 80% of the time the culprit is context, not prompt count.
### Output tokens cost 5x input tokens
API pricing has two numbers for a reason. Input tokens (what you send) are cheap. Output tokens (what Claude writes back) are 5x more expensive across every model. A request that costs $0.10 in input can cost $0.50 in output if Claude writes a long file.
This matters most for Claude Code specifically, because code generation is output-heavy. "Rewrite this 400-line component" is an expensive prompt. "Review this 400-line component and suggest 3 changes" is 10x cheaper.
**What to do.** Prefer targeted edits over full rewrites. Ask for diffs, not files. If you're on API billing, this one habit can cut your monthly spend in half.
### MCP servers and tool calls
Model Context Protocol servers extend Claude Code with external tools: GitHub, databases, browsers, custom APIs. They're powerful, but every tool call is a round-trip. Claude reads the tool's output, which adds to context, which adds to cost.
A single "check the last 20 PRs" MCP call can load 8,000 tokens of PR metadata into context, where it then sits for the rest of your session. Chain three or four MCP calls in one conversation and you've added 30K to 50K tokens of background noise to every subsequent prompt.
**What to do.** Audit which MCPs load on every session vs on-demand. Turn off ones you don't use. For expensive MCPs (like full repo indexers), prefer explicit calls over auto-loading.
### Prompt caching
This one cuts the other way. It's a hidden _saving_. Anthropic's prompt caching lets you reuse a portion of the context without paying full input price. Cache writes cost 1.25x the input rate, but cache reads cost just **10%** of the input rate.
For Claude Code, this matters enormously. Your system prompt, common project files, and long-running conversation history can all be cached. When caching works well, input costs can drop by 80 to 90%.
The catch: caching only helps on API billing. Pro and Max plans already include caching in their flat fee, but you don't see the savings, you just get slightly more effective usage. If you're on API, make sure caching is actually enabled. Many Claude Code configurations don't turn it on by default.
### The subscription-override trap
Worth repeating from earlier: if `ANTHROPIC_API_KEY` is set in your shell, Claude Code uses the API key and bills you at API rates, ignoring your $20 to $200 subscription entirely. People discover this when they see a $400 API bill on top of their $200 Max plan.
**What to do.** Run `echo $ANTHROPIC_API_KEY` in your terminal. If anything prints, either unset it before using Claude Code, or accept that your subscription is doing nothing.
### The meta-lesson
Claude Code's real cost isn't the plan you pick. It's how you work. A disciplined Pro user can get more done than a sloppy Max 20x user, because the Pro user isn't burning 200K tokens per session on stale context and verbose rewrites. Treat your context window like a budget, not a buffer.
## Where Duet fits
Every plan we've covered so far is a direct relationship with Anthropic. You pay them, you get tokens, you manage the seats yourself. For a lot of buyers, that's the right answer.
For others, it creates more problems than it solves: uneven usage across a team, bursty agency workloads, the 5-seat Team minimum, per-developer rate limits that don't pool, and the fact that billing is either predictable-but-wasteful (subscriptions) or flexible-but-volatile (API).
This is the gap managed platforms like [Duet](/) fill.
### What "managed" actually means
Instead of every developer installing Claude Code locally with their own API key or subscription, Duet runs Claude inside a shared team environment. Each teammate gets access through the same workspace, so prompts, context, and conversations happen in one place the whole team can see.
The pricing implication is what most people come for: **monthly plans with shared included credits and a paid reserve for overage.**
### When Duet beats buying Anthropic direct
**A team of 3 to 10 with uneven usage.** Anthropic's Team plan demands 5 Premium seats at $100 each, even if two developers use Claude Code twice a week. Duet's included monthly credits are shared across the workspace instead of split into seat buckets.
**You want a predictable base with visible overage.** Duet's plan price sets the monthly base, while the paid reserve makes a heavy month explicit through manual or automatic topups and invoices for every charge.
**You want shared context.** In Claude Code direct, every developer's session is siloed. On Duet, your team works in durable shared sessions, so research, decisions, and prior results stay available instead of being trapped in individual terminals.
**You're an agency rotating across client codebases.** Duet lets you spin up separate workspaces per client without separate Anthropic subscriptions, and usage pools across your team rather than being pinned to individual seats.
**You want Claude Code _plus_ the rest of your stack.** Duet combines Claude access with integrations for GitHub, Google Sheets, Slack, and hundreds of other tools through managed integration boundaries. You're not just paying for Claude. You're paying for the surrounding infrastructure that makes Claude useful for teams.
### When buying Anthropic direct beats Duet
We said we'd be honest, so:
- **Solo developer on Pro ($20/mo).** Nothing beats Pro for a single dev with modest usage. Don't overthink this.
- **Hardcore single-user on Max 20x.** If you're one person doing 300M+ tokens a month through Claude Code exclusively, $200/month direct is the unbeatable option.
- **Enterprise with SSO, HIPAA, or procurement constraints.** Anthropic Enterprise is the right answer when compliance is in the room.
- **Pure API automation.** If you're wiring Claude into a product (not developers), the API is the right primitive.
### The actual comparison
| Buyer type | Best option |
| -------------------------------- | ---------------------- |
| Solo dev, under 50M tokens/mo | Anthropic Pro |
| Solo power user, 200M+ tokens/mo | Anthropic Max 20x |
| Team of 3–4, uneven usage | **Duet** |
| Team of 5+, even usage | Anthropic Team Premium |
| Team of 5+, uneven or bursty | **Duet** |
| Agency with multiple clients | **Duet** |
| Regulated enterprise | Anthropic Enterprise |
| Pure API / product integration | Anthropic API |
Duet isn't trying to replace Claude Code for individual developers.
It's trying to fix the awkward middle, teams and agencies where Anthropic's per-seat math stops making sense, while bundling in the collaboration layer Claude Code doesn't have on its own.
If that's your situation, [check the pricing page](/pricing). If you're a solo dev coding on weekends, stick with Pro. We'll still be here when your team grows.
## Epilogue
Claude Code pricing looks complicated because it is, but once you strip away the tiers and the token tables, the decision comes down to three questions:
**How much do you actually use it?** Under 50M tokens a month, Pro or API is fine. Over 200M, Max 20x wins by a mile. The middle is where choices matter.
**Are you one person or a team?** Anthropic's direct plans reward individuals and penalize uneven teams. A managed platform evens that out.
**How much do you care about predictability?** API pricing is the cheapest option on a good month and the most expensive on a bad one. Subscriptions flatten that curve. Managed platforms flatten it further.
The worst outcome isn't overpaying by $50/month. It's picking a plan, hitting a wall mid-afternoon, and losing three hours of flow state to a rate limit. Whatever you pick, pick it with enough headroom to not think about it again.
## Still guessing?
If you're a solo developer, [Anthropic's pricing page](https://claude.com/pricing) is the right place to start. Grab Pro or Max and get back to shipping.
If you're a team of 3+ with uneven usage, an agency juggling client codebases, or anyone who wants Claude access bundled with team collaboration and shared context, compare [Duet's monthly plans](/pricing).
No per-seat buckets, visible reserve overage, and no 5-hour walls in the middle of a sprint.
[See Duet pricing →](/pricing)
## Frequently Asked Questions
### Is Claude Code free?
No. There is no free Claude Code tier. You need at least a Pro subscription ($20/month), a Max plan, a Team Premium seat, or API credits to use it. Anthropic briefly experimented with including Claude Code in free tiers but walked it back.
### How much does Claude Code cost per month?
Claude Code costs $20/month on Claude Pro, $100/month on Claude Max 5x, or $200/month on Claude Max 20x. Team plans are $100/seat/month for Premium seats (minimum 5 seats). You can also pay per token through the Anthropic API, which ranges from $1 to $25 per million tokens depending on the model.
### How much is Claude Max?
Claude Max comes in two tiers: Max 5x at $100/month and Max 20x at $200/month. Both run the same models as Pro (Sonnet 4.6 and Opus 4.7) — you're paying for a bigger usage bucket, not smarter Claude. Max 5x gives roughly 5x Pro's token allowance per 5-hour window; Max 20x gives roughly 20x. If Claude Code is your primary IDE, Max 20x is the plan; if you just hit Pro's limits a couple times a week, Max 5x is the sweet spot.
### How much is Claude Pro?
Claude Pro is $20/month and is the cheapest way to use Claude Code — there is no free tier. It includes both Claude.ai chat and Claude Code, sharing one usage limit of roughly 44,000 tokens per 5-hour window. It's the right pick for solo devs and side projects under about 50M tokens/month.
### What's the difference between Claude Pro and Claude Code?
Claude Pro is the $20/month subscription that includes Claude.ai (the chat interface) _and_ Claude Code (the coding agent in your terminal). They share the same usage limits. "Claude Code pricing" is really "Claude subscription pricing, applied to Claude Code."
### Claude Pro vs Max: which gives more of everything?
Roughly, yes. Max 5x gives you about 5x the token allowance of Pro per 5-hour window, and proportionally larger weekly limits. Max 20x gives you about 20x Pro. The model access is identical across tiers. You're paying for a bigger bucket, not better Claude.
### Can you use a Pro subscription for Claude Code on the API?
No, these are separate billing systems. Your Pro or Max subscription covers usage through Claude Code's built-in authentication. API access is billed separately per token. And if you have `ANTHROPIC_API_KEY` set in your environment, Claude Code will use the API and bill you separately from your subscription.
### What happens when I hit my Claude Code usage limit?
On Pro and Max, Claude Code stops responding until your 5-hour window resets. If you've enabled "extra usage," overflow continues at standard API rates up to a monthly cap you set. On the API, there's no cap. You keep paying per token.
### Is Claude Max 20x worth it for most developers?
Only if Claude Code is your primary development environment and you're coding 6+ hours a day. For most working developers, Max 5x at $100/month is the sweet spot. For occasional users, Pro is enough.
### How do Claude Code team plans work?
Anthropic Team plans start at $20/seat/month (annual) for Standard access, but Claude Code specifically requires a Premium seat at $100/seat/month (annual) or $125/seat/month (monthly), with a minimum of 5 seats. You can mix Standard and Premium seats on one team. Usage does not pool across seats. Each developer has their own limits.
### Is there a cheaper alternative to Claude Max 20x for heavy users?
The honest answer is no, not from Anthropic directly. Max 20x at $200/month is already priced aggressively versus API equivalent usage. If you're a team, managed platforms like Duet can be cheaper because usage pools across developers, but for a single power user, Max 20x is the best deal in the market.
### Does Claude Code pricing include Opus 4.7?
Yes. As of April 2026, Opus 4.7 is available on all paid tiers: Pro, Max 5x, Max 20x, and Team Premium. Anthropic has moved Opus 4.6 to legacy status. The free tier remains limited to Sonnet 4.6. Check [Anthropic's pricing page](https://claude.com/pricing) for the latest model lineup.
### Can you switch between Claude Code plans?
Yes. You can upgrade or downgrade monthly. Downgrades take effect at the next billing cycle. There are no long-term contracts for Pro or Max. You can drop from Max 20x back to Pro anytime.
## One more thing
Claude Code pricing is a moving target. Anthropic adjusts tiers, introduces new overflow toggles, and shifts model lineups every few months. Bookmark this post, or subscribe to Duet's newsletter where we track pricing changes the week they land.
[Try Duet free →](/pricing)
### Keep reading
- [How to run Claude Code in the cloud 24/7](/blog/how-to-run-claude-code-in-the-cloud)
- [Claude Duet: the always-on Claude Code workspace](/guides/duet-ai-for-founders)
- [Duet vs Claude Code: what's actually different](/guides/duet-vs-claude-code)
- [Claude Code for founders: GTM and ops automation](/guides/claude-code-for-founders)
- [Codex vs Claude Code: which coding agent to run](/blog/codex-vs-claude-code)
- [Claude Code vs Cursor vs Codex](/blog/claude-code-vs-cursor-vs-codex)
---
Source: https://duet.so/blog/claude-code-skills-marketplace
# Claude Code Skills Marketplace 101
*Learn where to find Claude Code skills, how to review them safely, and how to keep reusable instructions in a Duet workspace without depending on a proprietary catalog.*
By Duet Team. Published 2026-06-16, updated 2026-07-12. 5 min read.
Claude Code skills are reusable instruction packages. A good skill gives an agent a focused procedure, the context it needs, and clear boundaries around tools and output.
Finding a skill is the easy part. The harder questions are whether you trust its instructions, whether it still matches the tools you use, and how your team will review updates. This guide covers a practical, vendor-neutral workflow.
## Where to Find Claude Code Skills
Start with official documentation and source repositories maintained by the tool vendor. Community collections and GitHub search are useful for discovery, but treat every result as third-party code: read the files before you run them, inspect install scripts, and check recent maintenance activity.
Useful sources usually fall into three groups:
- **Official examples.** Best for learning the supported shape and conventions.
- **Curated community lists.** Good for breadth, but curation is not a security review.
- **Project-specific skills.** Often the most valuable because they encode your own review process, naming, deployment steps, and acceptance checks.
There is no reason to adopt an entire collection. Copy the smallest useful unit and keep its history visible in version control.
## How to Review a Skill Before Using It
Review a skill as you would a small dependency.
1. **Read every instruction and script.** Look for shell commands, network calls, filesystem access, and credential handling.
2. **Check the scope.** A narrowly described skill should not request broad access or unrelated tools.
3. **Inspect its failure behavior.** It should stop safely when required input is missing and should not hide partial changes.
4. **Pin the source.** Record the repository and revision you reviewed instead of repeatedly pulling an unbounded latest version.
5. **Test with disposable data.** Prove the workflow before allowing access to production systems or customer information.
A polished README does not replace this review. Skills influence an agent's actions, so their instructions are executable policy even when they contain no traditional code.
## What Good Skills Look Like
The most reliable skills share four qualities.
**Fit.** They solve one recognizable job. A skill for preparing a release can own the checklist, evidence, and handoff without also trying to manage every engineering workflow.
**Boundaries.** They say what they may read or change, which tools they require, and when they must stop for a human decision.
**Verification.** They define observable evidence. “Deploy the app” is vague; “deploy staging, open the canonical URL, and retain the test result” is testable.
**Maintenance.** Their assumptions live close to the instructions and can be reviewed like any other project asset. When the underlying workflow changes, the skill changes with it.
## Using Skill Files in Duet
The current Duet web app does not have a dedicated skills marketplace or one-click skills manager. Duet can still work with reusable instruction files because each workspace has persistent Files and durable Sessions.
A simple workflow is:
1. Review a skill outside the workspace or in a disposable branch.
2. Add the approved instruction file and supporting scripts through Files or your normal repository workflow.
3. Start a Session and point the agent at those files.
4. Keep stable business facts and sources in Train rather than duplicating them inside every instruction file.
5. Connect external services through Integrations and grant only the permissions the workflow needs.
This keeps the source visible and portable. It also separates three concerns cleanly: Files own instructions and code, Train owns durable business context, and Integrations own external authorization.
## How to Share Your Own Skill
Version control is the simplest distribution mechanism. Put the skill in a focused repository or a clearly named project directory, include a license, document required tools and permissions, and tag reviewed releases. Consumers can then inspect exactly what changed between versions.
If you maintain a public collection, publish review criteria and make provenance obvious. If you maintain an internal collection, require the same code-review process used for other automation that can access company systems.
## Frequently Asked Questions
### Is there a Claude Code skills marketplace?
The ecosystem includes official examples, public repositories, and community indexes. Their guarantees differ, so verify the source and review the actual files rather than treating “listed in a marketplace” as proof of safety.
### Where can I find Claude Code skills to install?
Start with the vendor's official documentation and repositories, then use curated community lists or GitHub search for broader discovery. Prefer projects with clear provenance, recent maintenance, and readable install steps.
### How do I publish a skill?
Publish the instruction file and any supporting code in a versioned repository. Document its purpose, required tools, permissions, expected output, failure behavior, and a small verification example.
### Does Duet have a skills catalog?
Not in this release. Store approved reusable instructions in workspace Files, keep stable sources in Train, and authorize external tools through Integrations. Sessions provide the durable record of how those instructions were used.
### Do I need to be a developer to use a skill?
Not always, but someone should review what the skill asks the agent to do. If it runs scripts, changes systems, or handles credentials, involve a person who can evaluate those risks before using it with real data.
---
Source: https://duet.so/blog/claude-code-vs-cursor-vs-codex
# Claude Code vs Cursor vs Codex (2026): Which AI Coder Wins
*Honest 2026 comparison of Claude Code, Cursor, and Codex — speed, pricing, agent quality, and when to pick each. Updated for Opus 4.7 and GPT-5.5.*
By Duet Team. Published 2026-03-01, updated 2026-05-21. 9 min read.
_Last updated: May 2026_
Claude Code, Cursor, and Codex are the three leading AI coding tools in 2026, but they are different kinds of product. Claude Code is Anthropic's terminal agent running Claude Opus 4.7. Cursor 3.3 is a VS Code fork built around inline AI editing and Bugbot. Codex is OpenAI's GPT-5.5 agent with multi-day automations across cloud, IDE, browser, and CLI.
## TL;DR — Claude Code vs Cursor vs Codex
| Tool | What it is | Default model | Best for | Pricing |
| --------------- | ------------------------------------------ | ----------------- | --------------------------------------------------- | ------------------------------ |
| **Claude Code** | Terminal-based coding agent from Anthropic | Claude Opus 4.7 | Architectural refactors, multi-file reasoning | $20–$200/mo (Claude Pro / Max) |
| **Cursor 3.3** | VS Code fork with AI completion + Bugbot | Claude Sonnet 4.6 | Active in-IDE coding, autocomplete, in-editor agent | $20 Pro / $40 Teams |
| **Codex** | OpenAI's cross-surface agent product | GPT-5.5 | Multi-day automations, plugin-heavy workflows | $20 Plus / API usage |
**Questions this page answers**
- What is the difference between Claude Code, Cursor, and Codex?
- What is Claude Code?
- What is Cursor?
- What is Codex?
- When should I use Claude Code vs Cursor vs Codex?
- How do these compare to a cloud agent workspace like Duet?
## What is Claude Code?
Claude Code is Anthropic's official command-line coding agent. It runs Claude Opus 4.7 (released April 2026) by default, with Claude Sonnet 4.6 available for cheaper turns, and has direct access to your filesystem, terminal, and any tool exposed through MCP (Model Context Protocol).
It is best understood as an _agent_, not an autocomplete: you give it a task, it reads files, runs commands, edits code, and reports back. The 200K-token context window plus Anthropic's prompt caching makes whole-codebase reasoning practical without runaway costs.
**Key strengths:**
- Whole-codebase analysis before making changes
- Multi-step autonomous workflows (branch, edit, test, PR)
- Native MCP support for third-party integrations
- Language- and framework-agnostic
- Terminal-first design that fits existing developer workflows
**Key limitations:**
- No inline autocomplete or tab completion
- Requires comfort with the terminal
- Large-context turns can get expensive without caching discipline
- No native GUI for staged review before execution
## What is Cursor?
Cursor is a fork of VS Code built specifically for AI-assisted development. The 3.3 release (May 2026) adds **durable canvases** for multi-step plans and **Bugbot**, an in-editor agent that triages and fixes bugs autonomously (Cursor reports ~78% self-resolution on Bugbot's own fixes).
Cursor's default chat model is Claude Sonnet 4.6, with Claude Opus 4.7 and GPT-5.5 available on Pro+. It charges $20/month for Pro (unlimited completions, 500 premium model requests) and $40/month for Teams (shared rules and prompts).
**Key strengths:**
- Best-in-class inline autocomplete and tab completion
- Familiar VS Code interface with near-zero learning curve
- `Cmd+K` to rewrite code with natural language
- Durable canvases that persist plans across sessions
- Bugbot runs in the background without blocking active work
- Team-level shared rules, prompts, and rulesets
**Key limitations:**
- Context limited to open files plus explicit includes
- Less effective for large architectural changes across many files
- Suggestions can be distracting during focused work
- Premium model quota can throttle heavy users
## What is Codex?
Codex is OpenAI's full agent product — not the legacy code model of the same name. As of April 2026 it has 4M weekly active users (up ~33% in two weeks) and defaults to GPT-5.5 with a 400K-token context window. It runs across **cloud, IDE, browser, and CLI**, with 90+ first-party plugins (Atlassian, GitLab, Microsoft Suite) and persistent memory.
The headline 2026 feature is **multi-day automations**: Codex can run jobs that span hours or days without supervision, picking up across sessions. This is OpenAI's direct push into the persistent-execution territory previously owned by purpose-built agent platforms.
**Key strengths:**
- GPT-5.5 default with 400K-token context and strong tool-use reliability
- Multi-day automations and persistent memory across sessions
- Same agent across cloud, IDE, browser, and CLI
- 90+ first-party plugins for major SaaS suites
- Plus plan at $20/month covers most personal usage; API pricing competitive at scale
**Key limitations:**
- Multi-day jobs run on OpenAI infrastructure, not yours — less filesystem control
- Plugin ecosystem is broad but uneven; not all integrations support write actions
- Premium quotas can throttle long automations on Plus
- Tied to OpenAI's stack — switching providers means leaving the product
## When should you use each?
**Use Claude Code when:**
- You need to refactor across many files and want the agent to read the codebase first
- You're debugging an issue that spans backend, frontend, and tests
- You want a terminal-first agent that can run scripts and tests autonomously
- You care about reasoning quality over completion speed
**Use Cursor when:**
- You're writing new features and want fast inline completions
- You prefer a full IDE with diff review, side-by-side panes, and a familiar VS Code feel
- You want Bugbot cleaning up bugs in the background while you keep building
- Your team needs shared rules and prompts synced across developers
**Use Codex when:**
- You need long-running, low-touch automation (multi-day jobs, scheduled CI tasks)
- You're already standardized on OpenAI and want one agent across cloud, IDE, and CLI
- You depend on plugin coverage for Atlassian, GitLab, or Microsoft Suite
- You want persistent memory across sessions without managing infrastructure
Most high-velocity teams use at least two of the three: Cursor for daily feature work, Claude Code for architectural changes, and Codex for automated workflows. The [How to Build and Ship an Internal Tool in a Day Using AI](/blog/how-to-build-internal-tool-in-a-day-with-ai) workflow shows how those tools layer in practice.
## How do they compare to a cloud agent workspace like Duet?
Claude Code, Cursor, and Codex are coding tools — they help one developer write or change code. A cloud agent workspace like [Duet](/) is a different category: it is a persistent server that hosts agents, files, memory, scheduled jobs, apps, and durable team sessions in one place.
The practical distinction is **Build + Run**. Coding tools build software. A cloud agent workspace also runs it: long-lived jobs, hosted internal apps, scheduled crons, shared team context, and integrations all live on the same server and survive when your laptop closes. Claude Code can be _used inside_ Duet, the same way Cursor can be used on your laptop. They are complementary, not competitors.
For teams that already use Claude Code in the cloud, the [How to Run Claude Code in the Cloud](/blog/how-to-run-claude-code-in-the-cloud) guide walks through a persistent setup; Duet provides that infrastructure out of the box.
## Model quality and context handling
**Reasoning quality.** Claude Opus 4.7 and GPT-5.5 are the two top-tier models in May 2026. Opus 4.7 still leads on architectural reasoning and codebase-wide refactors — its tool-use and "stay on task" behavior tend to beat GPT-5.5 on long, ambiguous changes. GPT-5.5 has closed the gap on raw code generation and is competitive on most discrete tasks.
**Context handling.** Codex's 400K-token context window exceeds Claude Code's 200K, useful when dumping a large schema and resolver tree into one turn. In practice, both handle multi-file analysis well; the bottleneck is usually how the agent chooses what to load, not the raw window size.
**Cost.** Claude Code costs roughly $3–$15 per million tokens (Sonnet 4.6 vs Opus 4.7). Codex costs $1.25–$10 per million tokens for GPT-5.5 (cached vs uncached). For heavy usage they are comparable; the real difference is context discipline.
## Cost ranges for startups
- **Cursor:** $20/user (Pro), $40/user (Teams). A 5-person team typically spends $100–$200/month.
- **Claude Code:** Variable. $50–$200/user/month for normal use, $500+/month for heavy architectural work. A 5-person team typically spends $250–$1,000/month.
- **Codex:** $20/user (Plus) or API usage. $10–$100/month for typical automations, $500+/month for heavy scripted use.
Most startups spend $500–$2,000/month total across AI coding tools — well below the developer hours they replace.
## Frequently Asked Questions
### What is the difference between Claude Code, Cursor, and Codex?
Claude Code is a terminal-based coding agent from Anthropic running Claude Opus 4.7, focused on whole-codebase reasoning and autonomous multi-file workflows. Cursor 3.3 is a VS Code fork built around fast inline AI editing and Bugbot, an in-editor agent that resolves bugs in the background. Codex is OpenAI's cross-surface agent product on GPT-5.5, with multi-day automations and 90+ plugins across cloud, IDE, browser, and CLI.
### Is Claude Code better than Cursor in 2026?
Claude Code is better for full-codebase analysis, architectural changes, and autonomous multi-step workflows. Cursor is better for inline editing, autocomplete, and active in-IDE coding sessions. Most teams use both: Cursor for daily feature work, Claude Code for refactors and debugging across many files.
### Which model does each tool use by default?
Claude Code defaults to Claude Opus 4.7 with Sonnet 4.6 available for cheaper turns. Cursor 3.3 defaults to Claude Sonnet 4.6, with Opus 4.7 and GPT-5.5 available on Pro+. Codex defaults to GPT-5.5 with a 400K-token context window.
### How does Codex compare to Claude Code?
Codex offers stronger persistence — multi-day automations, persistent memory, and the same agent across cloud, IDE, browser, and CLI. Claude Code offers stronger filesystem semantics and runs locally in your terminal with direct access to your environment. For long-running automation, Codex is often the right pick; for hands-on architectural work, Claude Code usually wins.
### Can you use Claude Code, Cursor, and Codex together?
Yes. They do not conflict and most high-velocity teams use at least two of the three. A common pattern is Cursor for in-IDE feature work, Claude Code for refactors and debugging, and Codex for scheduled or multi-day automations.
### How do they compare to Duet?
Duet is a cloud agent workspace, not a coding tool — it hosts agents, files, memory, scheduled jobs, apps, and durable sessions on a persistent server. Claude Code, Cursor, and Codex build software; Duet builds and _runs_ it. The categories are complementary: coding agents can run inside a Duet workspace while the work history and outputs persist. For head-to-head breakdowns, see [Duet vs Claude Code](/guides/duet-vs-claude-code) and [Duet vs Codex](/guides/duet-vs-codex).
---
Source: https://duet.so/blog/claude-opus-4-7-gpt-5-4-extended-thinking-duet
# Claude Opus 4.7, GPT-5.4 & Extended Thinking: Pick Your AI Agent Model in Duet
*Most AI agent failures come from using the wrong model. Duet lets you pick the model and thinking depth per agent: Claude Opus 4.7, GPT-5.4, and more, so every task gets the right brain.*
By Duet Team. Published 2026-04-25, updated 2026-05-08. 15 min read.
Duet runs Claude Opus 4.7 by default and supports GPT-5.4 through the Codex runner, with per-agent control over the model and how many reasoning tokens (up to 32,000) the agent uses before acting.
Most AI agent platforms pick a model for you. You get whatever the platform decided was "good enough," and when your agent hallucinates through a multi-step workflow or burns tokens on a simple lookup, you have no recourse.
That's a problem. Because the model behind your agent is the single biggest determinant of whether it produces something useful or something you spend 20 minutes fixing.
Different tasks need different brains. A competitor price scraper doesn't need the same reasoning depth as a tool that generates weekly financial summaries from three different data sources. An agent writing a Slack bot doesn't need the same model as one debugging a production deployment pipeline.
Duet now gives you two controls that most agent platforms don't: **model selection** and **thinking depth**. Per agent. Switchable anytime.
**Claude Opus 4.7, GPT-5.4 & Extended Thinking in Duet**
Duet now defaults to Claude Opus 4.7 for every agent and adds GPT-5.4 through the Codex runner at $2.50 per million input tokens. Pick the model and thinking depth per agent, with a new xhigh thinking level that gives the agent up to 32,000 reasoning tokens before it acts. Switch models mid-session without losing conversation history, tools, or memory.
## The Problem With One-Model-Fits-All Agents
Every AI model makes tradeoffs. Some are faster but shallower. Some reason deeply but cost more per token. Some excel at code generation but struggle with long-form analysis. Some handle ambiguity well but overthink straightforward tasks.
When a platform locks you into one model, you're stuck with those tradeoffs for every task your agent handles. That means:
- **Over-spending on simple tasks.** Your agent uses maximum reasoning power to rename a variable or send a notification. You're paying for a surgeon to apply a band-aid.
- **Under-powering complex work.** The same agent that handles quick lookups also attempts to build a multi-step data pipeline. It doesn't have the reasoning depth, so it hallucinates steps, skips edge cases, and you spend more time fixing the output than it would've taken to do it yourself.
- **No way to optimize.** You can't tune the agent for the task. You get what you get.
This is why model selection isn't a nice-to-have. It's the difference between an agent that works reliably and one that works "most of the time, kind of." If you've been [running Claude Code in the cloud](/blog/how-to-run-claude-code-in-the-cloud) at scale, you've already felt this on long sessions.
## Claude Opus 4.7: What Actually Changed
Every Duet agent now defaults to Claude Opus 4.7, Anthropic's most capable model. This isn't a minor version bump.
Here's what's materially different for agent work:
**Longer reasoning chains without drift.** Earlier models tend to lose the thread on tasks with many sequential steps. Opus 4.7 maintains coherence through much longer chains. If your agent is building a tool that pulls data from an API, transforms it, generates a report, and emails it, each step stays consistent with the ones before it.
**Better instruction following.** When you give your agent a specific constraint like "use this exact schema," "don't modify the database," or "format the output as a CSV with these headers," Opus 4.7 honors those constraints more reliably. Fewer "I interpreted your request differently" moments.
**More accurate code generation.** For agents that build and deploy tools, this matters most. Opus 4.7 produces code that runs on the first attempt more often. Fewer syntax errors, fewer wrong API calls, fewer "close but not quite" outputs that require manual correction.
**Edge case awareness.** This is subtle but compounds over time. Opus 4.7 is better at anticipating what might go wrong, including null values, rate limits, empty responses, and timezone issues, and handling them proactively. Your agents produce more robust outputs without you having to specify every defensive check.
If you're already using [Claude Duet](/guides/duet-ai-for-founders), you don't need to change anything. Your agents are already on Opus 4.7.
## Extended Thinking: When Your Agent Needs to Plan Before It Acts
Most agent failures happen in the first few seconds. The agent reads your prompt, picks a direction, and starts executing. If that initial direction is wrong, everything downstream is wrong too.
Extended thinking changes this. Before your agent writes a single line of code or takes any action, it reasons through the problem in a dedicated thinking phase. It plans the approach, identifies potential issues, and maps out the steps before committing to execution.
Duet now supports four thinking levels:
| Level | Reasoning tokens | When to use it |
| --------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Low | Minimal | Quick tasks: renaming files, simple lookups, sending a message. |
| Medium | Standard | General-purpose work: building a basic tool, writing a script. |
| High | Extended | Complex builds: multi-step workflows, tools with conditional logic. |
| **xhigh** | **Up to 32,000** | **Hard problems: debugging production issues, building systems with multiple integrations, intricate data transformations.** |
The new **xhigh** level gives your agent up to 32,000 tokens of reasoning before it acts. That's a meaningful window. In practice, it means your agent can:
- **Map out a full architecture** before writing any code. Instead of building a tool incrementally and realizing halfway through that the data model is wrong, the agent plans the entire structure upfront.
- **Anticipate failure modes.** With enough thinking tokens, the agent can reason about what happens when an API returns an error, when data is missing, or when a user provides unexpected input, before any of it actually happens.
- **Debug systematically.** Rather than making random changes to fix a bug, the agent can trace through the logic, form hypotheses, and test them methodically.
You don't need xhigh for most tasks. If your agent is doing a quick lookup or a simple text transformation, low or medium thinking is faster and cheaper. But when you're building something complex, like a competitive intelligence dashboard that pulls from five sources, a financial reporting tool with reconciliation logic, or a deployment pipeline with rollback handling, xhigh is the difference between "agent built something that mostly works" and "agent built something I'd ship."
### When to Use Each Thinking Level
**Low.** The task is straightforward and the agent doesn't need to plan. "Send this to Slack." "Rename these files." "Check if this URL returns 200."
**Medium.** Default for most work. Building a simple internal tool, writing a script, creating a basic automation.
**High.** The task has multiple steps that depend on each other, conditional logic, or requires integrating two or more systems. "Build a tool that scrapes competitor pricing, compares it to our data, and sends a summary."
**xhigh.** You've tried the task at a lower thinking level and the output wasn't right. Or you know upfront that the task is genuinely complex: multiple data sources, error handling across systems, tools with 10+ conditional paths, or debugging something that requires reading and understanding a large codebase.
## GPT-5.4: When Speed Matters More Than Depth
Not every agent task needs maximum reasoning. Some tasks need to be fast and cheap.
GPT-5.4 is now available in Duet through the Codex runner at **$2.50 per million input tokens**. It's a strong general-purpose model with fast inference. (For a full breakdown of the cost tradeoffs vs Anthropic, see our [Claude Code pricing guide](/blog/claude-code-pricing).)
Where GPT-5.4 makes sense:
- **High-volume, low-complexity tasks.** Agents that process hundreds of items, like categorizing support tickets, extracting fields from documents, or generating short descriptions. The task is simple per item, but you're running it at scale.
- **Latency-sensitive workflows.** If your agent needs to respond quickly, like a Slack bot that answers questions or a tool that surfaces data in real time, faster inference means a better experience.
- **Cost-sensitive operations.** Running an agent 24/7 on monitoring or alerting tasks. The work isn't complex, but it needs to be continuous and affordable.
Where GPT-5.4 is the wrong choice:
- Multi-step tool building where correctness matters more than speed.
- Tasks requiring deep reasoning about ambiguous requirements.
- Code generation for complex systems with many interdependencies.
The point isn't that one model is better. It's that **different agents in the same workspace can run different models**, and you should use that.
## How Model Selection Works in Practice
### Switch models mid-session. Keep everything.
This is the part most agent platforms get wrong. When you want to change models, they make you start a new session. You lose the conversation history, the context the agent built up, and whatever progress it made. So you don't switch. You stay on the wrong model because the cost of switching is too high.
In Duet, you switch models mid-session. No restart. No lost context. The session keeps its event history, tools, Train context, and workspace files. The only thing that changes is the reasoning engine behind it.
This matters more than it sounds. Say your agent is halfway through building a complex internal tool on Claude Opus 4.7. It's got the data model right, the API is working, but now it's stuck on a simple CSS layout issue. You can drop to GPT-5.4 for that one task (faster, cheaper) and then switch back to Opus for the next complex step. No progress lost.
Or the reverse: you started a task on medium thinking and the agent's output isn't quite right. Instead of scrapping the session and starting over with higher thinking, you just bump to xhigh and tell the agent to try again. It already has all the context from the failed attempt.
### Thinking depth works the same way
Adjust the thinking level between tasks, mid-session, without restarting. Start on medium for the scaffolding, bump to xhigh for the hard parts, drop back to low for cleanup.
### A practical example
Say you're running three agents in your workspace:
1. **Daily competitor monitor.** Scrapes pricing pages and sends a Slack summary. Runs on GPT-5.4 with low thinking. Fast, cheap, runs every morning. (See [how to set up a 24/7 AI agent](/blog/how-to-set-up-a-24-7-ai-agent) for the cron pattern.)
2. **Internal tool builder.** Your team requests custom dashboards and tools via a Slack command. Runs on Claude Opus 4.7 with high thinking. Needs accuracy and good code generation.
3. **Weekly analytics reporter.** Pulls data from PostHog, Stripe, and your database, generates a board-ready summary. Runs on Claude Opus 4.7 with xhigh thinking. The task is complex, the output needs to be polished, and it only runs once a week so cost isn't a concern.
Each agent gets the model and thinking level that matches its job. No compromises.
## What This Means for Your Agent Workflow
Model selection and thinking depth aren't features you configure once and forget. They're operational controls that directly affect how reliable, fast, and cost-effective your agents are.
The practical pattern:
1. **Start with defaults.** Opus 4.7 at medium thinking handles most tasks well.
2. **Upgrade thinking for complex work.** If an agent's output isn't reliable enough, increase thinking depth before trying anything else. It's the highest-leverage change you can make.
3. **Switch to GPT-5.4 for simple, high-volume tasks.** Don't pay for deep reasoning on tasks that don't need it.
4. **Match the model to the job, not the workspace.** Different agents can and should run different models.
---
These updates are live now. **Already on Duet?** Open any agent's settings to pick a model and thinking level. **New here?** [Try Duet free](/) and your first agent runs on Claude Opus 4.7 by default, with model and thinking controls one click away.
## Frequently Asked Questions
### Do I need to update anything to use Claude Opus 4.7?
No. Opus 4.7 is the default model for all Duet agents. Existing agents were automatically upgraded. You don't need to change any settings unless you want to switch to a different model.
### When should I use xhigh thinking vs. high thinking?
High thinking works for most complex tasks, including multi-step workflows, tools with conditional logic, and integrations between two or three systems. Use xhigh when the task has failed at lower thinking levels, or when you know upfront the task involves deep debugging, 10+ conditional paths, or building systems with multiple interdependent components. xhigh costs more in tokens but saves time by getting the output right on the first attempt.
### Can I use GPT-5.4 and Claude in the same workspace?
Yes. Each agent in your workspace can run a different model. You might have one agent on GPT-5.4 for quick daily tasks and another on Claude Opus 4.7 for complex builds. Switch models at any time without recreating the agent.
### What does GPT-5.4 cost in Duet?
GPT-5.4 is available inside every Duet monthly plan. Its work draws from included monthly credits first, then the paid reserve for overage.
### Can I switch models in the middle of a session?
Yes. Switch models or thinking levels at any point during a session. Your session keeps its full event history, tools, Train context, and workspace files. Nothing resets. You can use different models for different phases of the same task without starting over.
### How does model selection affect my agent's tools and memory?
It doesn't. The session history, tools, configuration, and workspace files stay the same when you switch models. Only the reasoning engine changes, so you can experiment without losing the setup.
### Is there a way to set a default model for all new agents?
Yes. Workspace-level default model settings are available. Set your preferred model once and all new agents in that workspace will use it. Individual agents can still be overridden.
### How does Claude Opus 4.7 compare to GPT-5.4 for AI agents?
They're tuned for different jobs. Claude Opus 4.7 is stronger on long-chain reasoning, instruction-following, and code generation, which makes it the better default for agents that build tools or run multi-step workflows. GPT-5.4 is faster and cheaper per token, which makes it the better choice for high-volume, latency-sensitive, or cost-sensitive tasks. The right move is usually to run both, with each agent on the model that fits its job.
---
Source: https://duet.so/blog/codex-vs-claude-code
# Codex vs Claude Code: Which AI Coding Agent Wins in 2026?
*Codex vs Claude Code compared: SWE-bench scores, $20 to $200 pricing, speed, and security. Which AI coding agent should you use in 2026? Full breakdown with a clear verdict.*
By Duet Team. Published 2026-05-02, updated 2026-07-20. 13 min read.
**Quick Summary**
Codex and Claude Code are the two leading AI coding agents in 2026. Both run in the terminal, both can edit files and execute commands autonomously, but they make fundamentally different tradeoffs. This comparison covers features, pricing, benchmarks, sandboxing, and the workflows where each tool actually wins.
**Questions this page answers**
- Is Codex or Claude Code better for coding in 2026?
- How does Codex CLI compare to Claude Code?
- What are the pricing differences between Codex and Claude Code?
- Which AI coding agent has better benchmarks?
- Can Codex and Claude Code run autonomously?
- What is the difference between Codex sandbox and Claude Code hooks?
## Codex vs Claude Code at a Glance
Both tools are terminal-native AI coding agents. You point them at a codebase, describe what you want, and they read files, write code, run commands, and iterate until the task is done.
The difference is in philosophy. Claude Code prioritizes reasoning depth and supervised autonomy. Codex prioritizes speed, parallelism, and open-source flexibility.
| | Claude Code | Codex CLI |
| --------------- | ---------------------------- | ----------------------------- |
| Developer | Anthropic | OpenAI |
| Default model | Claude Opus 4.6 / Sonnet 4.6 | GPT-5.4 / GPT-5.3-Codex |
| Context window | 1M tokens | 1.05M tokens |
| License | Proprietary (free to use) | Apache 2.0 (open source) |
| Sandbox | Permission-based (hooks) | OS-level (Seatbelt, Landlock) |
| Autonomy modes | Plan mode, auto-accept | Suggest, auto-edit, full-auto |
| Cloud execution | Via third-party (Duet, etc.) | Native (ChatGPT dashboard) |
| MCP support | Yes (native) | Yes (via config) |
| GitHub stars | ~40K | ~67K |
## What is Claude Code?
Claude Code is Anthropic's official CLI agent. It connects Claude Opus 4.6 or Sonnet 4.6 directly to your filesystem and terminal, letting the model read your entire codebase, edit files, run tests, and execute multi-step workflows.
The 1M token context window is the largest of any coding agent. In practice, Claude Code uses intelligent context management rather than loading everything at once, but the headroom means it handles large monorepos without chunking workarounds.
**What sets it apart:**
- **Hooks system.** 17 lifecycle events (PreToolUse, PostToolUse, Notification, etc.) let you run custom scripts before or after any tool call. You can enforce linting on every file write, block dangerous commands, or trigger CI pipelines automatically.
- **Plan mode.** Claude Code can explore a codebase and propose a structured implementation plan before writing any code. You review and approve the plan, then it executes.
- **MCP integration.** Native support for Model Context Protocol servers means you can connect Claude Code to databases, APIs, design tools, or any custom data source.
- **Subagent architecture.** Claude Code spawns specialized child agents for parallel subtasks (file search, test execution, research) while maintaining a coordinating parent context.
**Limitations:**
- No open-source option. You need a Claude API key or Claude Pro/Max subscription.
- No native cloud execution. Running Claude Code persistently requires setting up your own server or using a platform like [Duet](/).
- No built-in parallel task execution from a dashboard. It's one agent, one terminal session.
## What is Codex CLI?
Codex CLI is OpenAI's open-source terminal agent, released under Apache 2.0. It runs GPT-5.4 or GPT-5.3-Codex against your local codebase with OS-level sandboxing that restricts file and network access during execution.
The open-source approach has driven rapid adoption. Over 67,000 GitHub stars and an active contributor community mean the tool evolves quickly and integrates with a wide range of workflows.
**What sets it apart:**
- **Open source.** You can fork it, modify it, embed it in CI pipelines, or run it with any OpenAI-compatible API endpoint.
- **OS-level sandboxing.** On macOS, Codex uses Apple's Seatbelt framework. On Linux, it uses Landlock LSM and seccomp-bpf. This provides kernel-enforced isolation rather than relying on the model to respect permission boundaries.
- **Full-auto mode.** Codex can run completely autonomously with network access disabled, applying changes and running commands without any human approval steps.
- **Native cloud execution.** Through ChatGPT Pro/Plus, you can spawn Codex agents in the cloud, run multiple in parallel, and manage them from a web dashboard.
- **Token efficiency.** OpenAI claims GPT-5.3-Codex processes 4x more tokens per dollar than competing models at similar quality levels.
**Limitations:**
- Sandbox restrictions can block legitimate workflows. If your task requires network access (installing packages, hitting APIs), full-auto mode won't work, and you need to step through approvals.
- Cloud execution requires a ChatGPT subscription. The open-source CLI alone doesn't include cloud features.
- Smaller ecosystem of first-party integrations compared to Claude Code's MCP ecosystem.
## Feature Comparison
### Context and Reasoning
Claude Code's 1M token context and Opus 4.6 model give it an edge on tasks that require understanding large, interconnected codebases. Architectural refactors, debugging issues that span multiple services, and planning complex migrations are where the deeper reasoning model pays off.
Codex's 1.05M context is technically larger, but the practical difference is negligible. Where Codex differs is in speed. GPT-5.3-Codex was built for high-throughput code tasks and returns results faster on straightforward implementations.
### Autonomy and Safety
The tools take opposite approaches to the autonomy-safety tradeoff.
Claude Code uses a **permission-based model**. By default, it asks before executing commands or writing files. You can relax this with auto-accept flags or hooks that whitelist specific operations. The hooks system gives you fine-grained control: you can allow `npm test` but block `rm -rf`, permit writes to `src/` but not `.env`.
Codex uses **sandbox-based isolation**. In full-auto mode, the model runs freely but inside a kernel-enforced sandbox that prevents network access and restricts filesystem operations to the project directory. The philosophy is: let the model do whatever it wants, but limit what damage it can do.
Neither approach is strictly better. Claude Code's permission model is more flexible but relies on correct configuration. Codex's sandbox is more restrictive but harder to misconfigure.
### Cloud and Parallel Execution
Codex has a clear advantage here. ChatGPT Pro subscribers can launch multiple Codex agents simultaneously from a web dashboard, each working on a separate branch or feature. The agents run in cloud sandboxes and deliver pull requests when done.
Claude Code doesn't offer native parallel execution. Running multiple instances requires multiple terminal sessions, and there's no built-in dashboard to manage them. Platforms like [Duet](/) solve this by providing persistent cloud environments where Claude Code agents run 24/7 with team-wide visibility.
### Extensibility
Claude Code's MCP support is more mature. You can connect it to Postgres databases, Figma designs, Notion pages, Slack channels, and thousands of other tools through MCP servers. The hooks system adds another layer: you can trigger external scripts on any lifecycle event.
Codex supports MCP through configuration but has fewer first-party integrations. The open-source nature compensates, as the community builds adapters and plugins, but the out-of-the-box integration story is thinner.
## Benchmark Comparison
Benchmarks are imperfect proxies for real-world performance, but they're the closest thing to an objective comparison.
| Benchmark | Claude Code (Opus 4.6) | Codex (GPT-5.3-Codex) |
| ----------------------------- | ---------------------- | --------------------- |
| SWE-bench Verified | 80.9% | ~80% |
| Terminal-Bench | 65.4% | 77.3% |
| Aider polyglot | 68.6% | 62.8% |
| Blind code quality preference | 67% win rate | 33% win rate |
**What the numbers mean:**
- **SWE-bench** tests the ability to fix real GitHub issues. Both tools are essentially tied, meaning either can handle standard bug fixes and feature implementations.
- **Terminal-Bench** measures shell and system administration tasks. Codex leads significantly here, suggesting GPT-5.3-Codex is better at command-line operations and system-level work.
- **Aider polyglot** tests multi-language code editing. Claude leads, reflecting stronger performance on complex multi-file edits.
- **Blind preference** studies show developers prefer Claude's code quality 2:1 when they don't know which model wrote it. This aligns with the general pattern: Claude produces more readable, well-structured code on complex tasks.
The takeaway: Claude Code tends to produce higher quality output on complex reasoning tasks. Codex tends to be faster and more efficient on straightforward coding and terminal operations.
## Pricing Comparison
Both tools offer a subscription tier and an API tier.
### Subscription Pricing
| Plan | Claude Code | Codex |
| ---------- | -------------------------- | ----------------------- |
| Entry tier | Claude Pro, $20/month | ChatGPT Plus, $20/month |
| Mid tier | Claude Max 5x, $100/month | ChatGPT Pro, $200/month |
| High tier | Claude Max 20x, $200/month | ChatGPT Pro, $200/month |
Claude Pro includes limited Claude Code usage. Max 5x provides 5x the usage cap, and Max 20x provides 20x. The exact token limits aren't published, but heavy users typically need Max 5x or above.
ChatGPT Plus includes Codex access with usage limits. Pro removes most limits and adds priority access to cloud execution.
### API Pricing
| | Claude Opus 4.6 | GPT-5.4 |
| ------ | --------------- | ------------ |
| Input | $5 / MTok | $1.25 / MTok |
| Output | $25 / MTok | $10 / MTok |
| | Claude Sonnet 4.6 | GPT-5.3-Codex |
| ------ | ----------------- | ------------- |
| Input | $1.50 / MTok | ~$0.50 / MTok |
| Output | $7.50 / MTok | ~$2 / MTok |
On raw API pricing, OpenAI's models are significantly cheaper per token. For teams running agents at scale through the API, this cost difference compounds. However, Claude's higher accuracy on complex tasks can offset the price difference if it means fewer iterations to reach a working solution.
## When to Use Claude Code
**Complex architectural work.** If you're refactoring a service layer, migrating a database schema, or planning a large feature that touches dozens of files, Claude Code's reasoning depth and plan mode give you higher confidence in the output.
**Teams with existing MCP infrastructure.** If your team already uses MCP servers for databases, design tools, or internal APIs, Claude Code integrates natively.
**Code quality is the priority.** When the output needs to be production-ready with minimal review, Claude's 2:1 blind preference advantage matters. This is especially relevant for open-source projects or codebases with strict review standards.
**Custom workflow automation.** The hooks system lets you build sophisticated guardrails and automations around Claude Code's execution. If you need every file write to pass a linter, every test run to report to Slack, or every PR to follow a specific template, hooks make this possible without modifying the tool itself.
## When to Use Codex
**Parallel task execution.** If you have 5 independent features to build or bugs to fix, Codex's cloud dashboard lets you run them simultaneously. Claude Code can't match this without external infrastructure.
**Terminal-heavy workflows.** Codex scores 12 points higher on Terminal-Bench. If your work involves heavy shell scripting, server administration, or CLI tool development, Codex handles it better.
**Budget-sensitive teams.** At roughly 2.5-4x lower API pricing, Codex is the better choice for teams running high-volume automated workflows where cost per token matters more than peak reasoning quality.
**Open-source requirements.** If you need to embed an AI coding agent in your CI pipeline, fork it for a custom workflow, or run it against a non-OpenAI API endpoint, Codex's Apache 2.0 license makes this possible. Claude Code is closed source.
**Security-first environments.** Codex's OS-level sandboxing provides stronger isolation guarantees than Claude Code's permission-based model. For regulated industries or security-conscious teams, the kernel-enforced sandbox is a meaningful advantage.
## Using Both Together
Many teams use both tools. The workflow typically looks like:
- **Claude Code for architecture and planning.** Use plan mode to analyze the codebase and design the approach for a large feature or refactor.
- **Codex for parallel implementation.** Once the plan is set, spawn multiple Codex agents to implement different parts of the plan simultaneously.
- **Claude Code for review and refinement.** Use Claude Code's deeper reasoning to review the Codex-generated PRs, catch subtle issues, and ensure consistency across the parallel outputs.
This isn't theoretical. Teams running both report that the combination ships faster than either tool alone, because you get Claude's reasoning quality for the hard parts and Codex's speed and parallelism for the straightforward parts.
## Running AI Coding Agents in the Cloud
Both tools benefit from cloud execution, but for different reasons.
Codex has native cloud support through ChatGPT. You get a dashboard, parallel agents, and managed infrastructure out of the box.
Claude Code requires a cloud setup. You either SSH into a VM and run it in tmux, or use a platform like [Duet](/) that provides persistent cloud environments with team collaboration, scheduling, and always-on execution.
The cloud advantage is the same for both: your agents keep working when you close your laptop, multiple team members can interact with the same session, and you get a consistent environment that doesn't depend on anyone's local setup.
## Frequently Asked Questions
### Is Codex better than Claude Code?
Neither tool is universally better. Codex is faster, cheaper per token, and offers native parallel cloud execution. Claude Code produces higher quality code on complex tasks and has deeper integration capabilities through MCP and hooks. For straightforward coding tasks, Codex is more cost-effective. For architectural work and complex reasoning, Claude Code delivers better results.
### Can I use Codex CLI for free?
Codex CLI is open source (Apache 2.0) and free to install. However, it requires an OpenAI API key to run, which means you pay per token for API usage. There is no completely free tier for running Codex against real codebases. ChatGPT Plus ($20/month) includes some Codex cloud usage.
### Is Claude Code open source?
No. Claude Code is a proprietary tool from Anthropic. It's free to install and use with a Claude API key or subscription, but you cannot fork, modify, or redistribute it. If open-source licensing is a requirement, Codex CLI is the better choice.
### Which AI coding agent is better for startups?
For most startups, Claude Code is the better starting point because of its stronger reasoning on complex tasks and plan mode for architectural decisions. Add Codex when you need parallel execution or have budget constraints on high-volume automated workflows. The $20/month entry tier is the same for both, so the real cost difference shows up at scale through API pricing.
### How do Codex and Claude Code handle security?
Codex uses OS-level sandboxing (Seatbelt on macOS, Landlock + seccomp on Linux) that restricts file and network access at the kernel level. Claude Code uses a permission-based model with hooks for custom validation. Codex's approach is harder to bypass but more restrictive. Claude Code's approach is more flexible but depends on correct configuration. Both prevent the model from accessing files outside the project directory by default.
### Can I run both Codex and Claude Code on the same project?
Yes. They don't conflict. Claude Code runs in one terminal, Codex in another. Many teams use Claude Code for planning and review, and Codex for parallel implementation. The only consideration is that both tools may modify the same files, so coordinate through git branches to avoid conflicts.
---
Source: https://duet.so/blog/custom-domain-names-in-duet
# Custom Domains for AI-Built Apps: Setup Guide for Duet
*AI-built tools on generic subdomains look like demos. Custom domains in Duet let you ship internal tools and client-facing apps on your own URL, with automatic HTTPS, in minutes.*
By Duet Team. Published 2026-04-25, updated 2026-05-08. 9 min read.
Duet apps can now run on your own domain. Add a CNAME record, and Duet handles verification, TLS provisioning, and routing automatically. Setup takes a few minutes per app, with no additional cost.
You built a client dashboard with AI in 20 minutes. It works. The data is live. The client could use it today.
Then you look at the URL: `app-7f3x2.duet.so`.
You're not sending that to a client. You're not sharing that with your team and calling it an internal tool. It looks like a prototype on someone else's platform, because that's exactly what the URL says.
This is the gap between "I built something useful" and "I shipped something my team actually uses." And it's a gap that kills adoption. People don't bookmark tools on random subdomains. They don't trust dashboards that look temporary. They don't integrate apps into their workflow when the URL screams "this might disappear."
Duet apps can now run on your own domain: `tools.yourcompany.com`, `reports.youragency.com`, `tracker.yourstartup.io`. Your URL, your brand, automatic HTTPS, active in minutes. (Once your tool is live on your domain, the next question is usually "how do I keep it running 24/7?" See [how to run Claude Code in the cloud](/blog/how-to-run-claude-code-in-the-cloud) and [how to set up a 24/7 AI agent](/blog/how-to-set-up-a-24-7-ai-agent).)
**Custom Domains in Duet**
Apps built in Duet can run on your own domain. Add a domain in Settings > Apps, point a CNAME to Duet, and Duet handles verification, TLS certificates, and routing automatically. Each app gets its own custom domain, with no additional cost. Setup takes minutes.
## The Problem With Default Subdomains
Every AI builder gives you a generated URL when you deploy something. It's fine for testing. It's a dead end for everything else.
Here's what actually happens when your tools live on generic subdomains:
**Internal tools don't get adopted.** You build a competitive intelligence dashboard for your sales team. You share the link in Slack. Half the team doesn't click it because the URL looks sketchy. The other half bookmarks it, but when they see `app-7f3x2.duet.so` in their bookmarks three weeks later, they've forgotten what it is. The tool quietly dies.
**Client-facing work looks amateur.** If you're an agency or freelancer building tools for clients, the URL is part of the deliverable. Sending a client to a generic subdomain undermines the value of what you built. It signals "quick hack" instead of "professional solution."
**IT and compliance get nervous.** In larger teams, tools on unknown domains trigger questions. "What is this?" "Is it approved?" "Who controls this?" Your own domain answers all of those questions before they're asked.
**No SEO or brand value.** If you're building public-facing tools like calculators, dashboards, or interactive content, a generic subdomain means zero brand association. Traffic goes to someone else's domain authority.
Custom domains solve all of this. Same tool, completely different perception.
## How Custom Domains Work in Duet
Three steps. No engineering, no DevOps tickets, no infrastructure to manage.
### Step 1: Add your domain
Go to **Settings > Apps** in [Duet](/guides/duet-ai-for-founders). Select the app you want to map. Enter the domain you want to use.
This works with root domains (`yourcompany.com`) or subdomains (`tools.yourcompany.com`, `reports.youragency.com`). Subdomains are the most common pattern for internal tools.
### Step 2: Point your DNS
Add a CNAME record in your DNS provider pointing your domain to Duet. This is the only step that happens outside of Duet. If you've ever set up a custom domain for anything (a blog, a landing page, an email service), this is the same process.
### Step 3: Duet handles the rest
Once DNS propagates (usually a few minutes), Duet automatically:
- Verifies domain ownership
- Provisions a TLS certificate (HTTPS from day one)
- Routes traffic to your app
- Tracks status in your settings panel
No manual certificate management. No nginx configs. No SSL renewal reminders.
## One Domain Per App. Unlimited Apps.
Each Duet app gets its own custom domain. This means you can build a coherent namespace for your tooling:
- `intel.yourcompany.com`: competitive intelligence tracker
- `metrics.yourcompany.com`: weekly KPI dashboard
- `onboard.yourcompany.com`: new hire onboarding checklist
- `pricing.yourcompany.com`: dynamic pricing calculator
Or if you're an agency building for clients:
- `reports.clientname.com`: automated reporting dashboard
- `analytics.clientname.com`: traffic and conversion analytics
- `pipeline.clientname.com`: sales pipeline tracker
All managed from the same settings screen in Duet. No separate hosting accounts, no server management, no deployment pipelines.
## What You Get
| Feature | Details |
| ---------------- | ------------------------------------------------------ |
| TLS certificates | Automatic provisioning and renewal, zero configuration |
| DNS verification | Guided setup with real-time status tracking |
| Routing | Automatic, no server configuration needed |
| Multiple domains | One per app, unlimited apps |
| Setup time | Minutes from DNS change to live app |
| Cost | Included for all Duet users, no additional charge |
| Subdomains | Full support, same setup process |
## When Custom Domains Change the Outcome
Custom domains aren't a cosmetic feature. They change whether the tool you built actually gets used.
**Internal tools that stick.** A dashboard on `metrics.yourcompany.com` gets bookmarked, shared in Slack, and becomes part of the team's daily routine. The same dashboard on a generated subdomain gets used twice and forgotten. (For more on shipping internal tools fast with AI, see [how to build an internal tool in a day with AI](/blog/how-to-build-internal-tool-in-a-day-with-ai).)
**Client deliverables that justify the fee.** When you hand a client a tool running on their own domain, it feels like a custom build, because it is. The perceived value jumps. The client shares it internally. It becomes a reference point, not a one-off.
**Public tools that build brand.** If you're using Duet to build free tools, calculators, or interactive content for lead generation, those tools on your domain drive SEO value and brand recognition back to you.
---
Custom domains are live now under **Settings > Apps**. **New to Duet?** [Start a free workspace](/) and ship your first app on your own domain in minutes.
## Frequently Asked Questions
### Is there an extra cost for custom domains?
No. Custom domains are included for all Duet users at no additional charge. You just need to own the domain and have access to its DNS settings.
### How long does it take for a custom domain to go live?
Once you add the CNAME record, Duet handles verification and TLS provisioning automatically. Most domains are active within a few minutes, depending on DNS propagation. Some DNS providers take up to 24 hours, but that's rare.
### Can I change or remove a custom domain later?
Yes. Update or remove custom domain mappings at any time from Settings > Apps. If you remove a domain, traffic reverts to the default Duet subdomain. Your app keeps working either way.
### Do I need to configure anything for HTTPS?
No. Duet provisions and renews TLS certificates automatically. Your custom domain serves over HTTPS from the moment it goes live. There's no manual certificate setup, no renewal process, and no downtime.
### Can I use a subdomain like tools.mycompany.com?
Yes. Subdomains are the most common setup. Point a CNAME for your subdomain to Duet and the rest is handled automatically. Most teams use patterns like `tools.company.com`, `reports.company.com`, or `app.company.com`.
### Can I use custom domains for client-facing apps?
Yes. If you're building tools for clients, you can either use a subdomain under your own domain (like `clientname.youragency.com`) or have the client point their own domain to the app. Both approaches work with the same CNAME setup.
### Do custom domains work with apps that use Claude or GPT-5.4 under the hood?
Yes. Custom domains apply to any Duet app, whether it's powered by Claude Opus 4.7, GPT-5.4, or another supported model. For more on choosing the right model for each app, see our guide to [picking your AI agent model](/blog/claude-opus-4-7-gpt-5-4-extended-thinking-duet).
---
Source: https://duet.so/blog/cut-enterprise-llm-spend
# How to Reduce LLM Cost Without Losing Quality: A Finance-First Decision Ladder
*Cut enterprise LLM spend without hurting output quality. A finance-first, 9-step decision ladder — from seat waste to model right-sizing to routing.*
By Duet Team. Published 2026-07-19, updated 2026-07-19. 15 min read.
> **Reduce LLM cost by lowering cost per successful task while holding a pre-defined quality and latency floor. Start with that floor and a spend baseline, stop runaway usage, and remove seat, markup, and default-model waste. Then right-size models by task. Reach for caching, routing infrastructure, or fixed compute only when workload math justifies them.**
Pick 50–200 representative tasks, set a pass/fail threshold, and name a rollback owner. Every lever below needs that quality gate before it's declared a win.
Most AI cost articles hand you a tactic list in no particular order. That's backward for a budget owner. Below is the order: cheapest and safest first, complexity last, only when the math earns it.
## What should you cut first when AI spend spikes?
Don't blanket-switch to a cheaper model. Freeze runaway usage and define your quality floor first — most enterprises hit by a spike have neither one.
[The Economist reported in June 2026 that companies are scrambling to curtail soaring AI costs](https://www.economist.com/business/2026/06/14/companies-are-scrambling-to-curtail-soaring-ai-costs), coining "tokenmaxxing" for unchecked usage — one big-tech executive called the coming squeeze "an absolute nightmare." Agents that read, interpret, and act burn more tokens than a chatbot; run across hundreds of programs, that spiral compounds fast.
The pattern repeats in team-level anecdotes: usage gets encouraged for months, costs triple almost overnight, and the bill was creeping up long before anyone with budget authority noticed. The fix isn't a panic downgrade — it's a baseline, a cap, and a floor, in that order.
## What actually drives enterprise AI cost?
Enterprise AI spend is at least four different economic problems, not one — each needs its own audit question.
Worldwide AI spending will hit [$2.52 trillion in 2026, up 44% year over year, according to Gartner](https://www.gartner.com/en/newsroom/press-releases/2026-1-15-gartner-says-worldwide-ai-spending-will-total-2-point-5-trillion-dollars-in-2026), with the AI Models segment at $26.4 billion. Enterprise-specific: [Menlo Ventures found LLM API spend doubled from $3.5 billion in late 2024 to $8.4 billion by mid-2025](https://menlovc.com/perspective/2025-the-state-of-generative-ai-in-the-enterprise/) — the most current published trend line.
| Cost shape | How it bills | Typical range | First audit question |
| ------------------------------- | ---------------------------------------------------------- | --------------------------------------------------- | --------------------------------------------------------------- |
| Per-seat licenses | Flat fee per user per month | $20–$25/seat/mo standard; $100–$125/seat/mo premium | Who actually uses it, and how much? |
| Direct token usage | Metered per million tokens, input/output priced separately | $0.14–$30 input per MTok across tiers | Which tasks burn the most tokens? |
| Marked-up usage | Token rate plus a tool or reseller's cut | Varies — often opaque | What's the actual pass-through rate over provider cost? |
| Committed / self-hosted compute | Fixed cost regardless of use | Case-by-case; depends on GPU utilization | Is utilization high and sustained enough to beat token pricing? |
Seat pricing spans a range: [ChatGPT Business runs $20–$25/user/month](https://openai.com/api/pricing/), Claude Team prices the same, and Claude Premium runs $100–$125/seat/month. A seat on top of [what Claude Code actually costs](/blog/claude-code-pricing) often means paying twice for the same work.
## What does LLM cost optimization actually mean?
The governing metric is cost per successful task, not cost per token — a cheap request that fails and needs a retry can cost more than a pricier one that succeeds first time.
A $0.002-per-call model succeeding 45% of the time needs 1.8 attempts on average — $0.0036 per successful task. A $0.01 model at 95% success needs 1.05 attempts — $0.0105. Change the failure rate and the ranking flips; illustrative arithmetic, not a benchmark, but the direction holds in production.
| # | Lever | Savings range | Quality risk | Effort | Proof required |
| --- | ---------------------------------- | ------------------------- | ------------ | --------- | ----------------------------------------- |
| 1 | Define quality floor + baseline | Enables everything below | None | 1 week | Golden eval set + cost-per-success metric |
| 2 | Remove commercial waste | 10–40% of bill | Zero | Days | Seat utilization audit |
| 3 | Stop runaway spend | Prevents crises | Zero | Days | Budget alerts + loop limits live |
| 4 | Enable prompt caching | 40–90% on repeated input | Zero | Config | Cache hit rate measured |
| 5 | Right-size models by task | 40–80% on model costs | Low–medium | 1–2 weeks | Golden eval pass rate at new tier |
| 6 | Batch latency-tolerant work | 50% on eligible workloads | Zero | Config | Eligible-volume audit |
| 7 | Reduce token waste | 10–30% on token costs | Low | 1–2 weeks | Output-token audit |
| 8 | Evaluate routing/gateway | 10–30% additional | Medium | 2–4 weeks | Manual-policy breakdown documented |
| 9 | Evaluate fixed/self-hosted compute | Variable | High | 4–8 weeks | Sustained-utilization math |
Steps 1–3 carry zero quality risk and take days; steps 8–9 carry real complexity and only get evaluated once the earlier steps are exhausted.
## How do you stop runaway AI spend before it becomes a crisis?
Install budgets, per-team spend alerts, and agent loop limits before chasing a percentage anywhere else — config changes, not infrastructure projects, with zero quality risk.
A per-team or per-agent budget with an alert before overage, not after, catches a spike while it's still cheap to fix. A max-iteration cap on any agent loop stops one runaway automation from becoming the month's line item — exactly the scenario The Economist's "hundreds of software programs" framing describes.
The overcorrection is just as common: after months of encouraging AI adoption, some organizations swing to a flat per-user cap overnight. That protects the budget but also blocks a power user doing valuable work while a light user's allowance goes unused. Scoped alerts beat blunt caps.
## Where is the commercial waste hiding in your AI bill?
Unused seats, reseller markup, and defaulting every task to the priciest model are pure waste — zero quality risk to remove, often 10–40% of the total bill.
Run the seat math before assuming either model wins. A 500-person team on $20/seat/month seats pays $10,000/month flat. Usage-based billing on a realistic mix — 50 power users at $50/month, 450 light users at $2/month — totals $3,400/month, 66% cheaper.
But if all 500 are power users at $50/month, usage billing hits $25,000/month, 150% more than seats. The answer depends entirely on your usage distribution — attribution comes before you pick a pricing model.
The same waste hides in model choice: defaulting every task to your most capable model is a premium-default tax. Our [breakdown of when the most expensive model isn't worth it](/blog/when-not-to-use-claude-fable-5) covers which tasks don't need frontier-plus pricing.
## How do you right-size models by task without losing quality?
Moving even part of a workload from a frontier model to a cheaper tier that still clears your quality floor is the single biggest lever here. Operationally, that means assigning a model per agent or task, not one default for everything.
| Tier | Model | Input | Output | Ratio to cheapest |
| --------------- | -------------------------------------------- | ------ | ------- | ----------------- |
| Budget open | DeepSeek V4 Flash | $0.14 | $0.28 | 1× |
| Budget open | DeepSeek V4 Pro | $0.435 | $0.87 | 3.1× |
| Mid proprietary | GPT-5.4-nano | $0.20 | $1.25 | 1.4× |
| Mid proprietary | Claude Haiku 4.5 | $1.00 | $5.00 | 7.1× |
| Mid open | Kimi K3 | $3.00 | $15.00 | 21.4× |
| Frontier | Claude Sonnet 5 (intro, through Aug 31 2026) | $2.00 | $10.00 | 14.3× |
| Frontier | Claude Opus 4.8 | $5.00 | $25.00 | 35.7× |
| Frontier | GPT-5.6-sol | $5.00 | $30.00 | 35.7× |
| Frontier+ | Claude Fable 5 | $10.00 | $50.00 | 71.4× |
| Frontier+ | GPT-5.5-pro | $30.00 | $180.00 | 214× |
_After Aug 31, 2026, Sonnet 5 reverts to standard pricing at $3/$15._
At 10 million input plus 2 million output tokens a day, Claude Opus 4.8 runs $3,000/month; the same volume on Claude Haiku 4.5 runs $600/month — 80% cheaper on workloads that clear Haiku's bar. Our [guide to choosing the right AI model per task](/blog/how-to-choose-the-right-ai-model-for-your-business) covers that line; [Kimi K3](/blog/kimi-k3-open-source-ai-models) pushes it further for structured work.
Right-sizing only sticks if it's a habit, not a one-time audit: someone needs to deliberately assign a model to each agent or task — the low-volume classification job on a budget tier, the customer-facing reasoning task on a frontier tier — and see, in plain dollars, whether that assignment is actually cheaper.
This is the operational form of everything above. Duet gives every agent in a workspace its own model choice across providers — OpenAI, Anthropic, and others — so right-sizing is a per-agent decision, not an all-or-nothing default.
Because Duet bills tokens at a flat rate per quality tier rather than per seat, the bill maps to actual usage — the same spend-visibility problem that hides seat waste above doesn't happen here. Workspaces stay private, and the pricing model itself avoids the light-user/heavy-user subsidy problem described earlier.
[Start a workspace and see the real per-agent cost.](https://app.duet.so/sign-in?from=blog-cut-enterprise-llm-spend)
## Can caching and batching cut cost with zero quality risk?
Yes — caching and batching cut cost with zero change to model quality. Enable both before touching model choice.
[Anthropic's prompt caching](https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching) gives a 90% discount on cache reads with one added request field; OpenAI applies the same discount automatically on prompts of 1,024+ tokens, no code changes. On a 10-million-token daily workload with a 60% cacheable prefix, steady-state cost drops from $50/day to $23/day — 54% off input costs alone.
[OpenAI's Batch API](https://platform.openai.com/docs/guides/batch) and Anthropic's Message Batches both cut cost 50% flat for latency-tolerant work — evals, classification, bulk generation, embeddings. On 1 million tokens/day of batchable work, that's $2/day to $1/day, same model, zero quality change. If your app repeats system prompts or RAG context, this is a billing fix, not an engineering project.
## When does model routing make sense — and when is it overkill?
Manual per-task model policy is enough for most organizations. Automated routing earns its complexity only once manual policy breaks under multiple teams, apps, and providers.
RouteLLM, a 2024 academic benchmark published at ICLR 2025, reported up to 85% cost reduction while holding 95% of GPT-4-level performance — but that figure is a specific MT-Bench configuration on GPT-4-era models, not a general production guarantee. It's also roughly two years old now; treat it as a directional research result, not an expected outcome for your traffic.
Vendor-modeled numbers push the same direction with less rigor: TrueFoundry reports that combining caching, routing, and on-prem shifts can "routinely deliver 50–80% cost reduction," including a hypothetical $150K-to-$60K/month scenario — a vendor-authored model, not an observed customer result.
For the mechanics of routing versus multi-model orchestration, see our [deep dive on orchestrator-worker patterns versus model routing](/blog/frontier-model-orchestrator); for routing within the Claude family specifically, see [Claude Opus vs. Sonnet model routing](/guides/claude-opus-vs-sonnet-model-routing). Routing is one ranked lever here, not the first purchase.
## When, if ever, does fixed or self-hosted compute make sense?
Committed or self-hosted compute only beats token-based pricing at sustained high utilization. It's not automatically cheaper, and it's the last rung to evaluate, not the first.
The break-even depends on GPU utilization and operations overhead most teams underestimate. In one widely shared account, a team said it was burning $50,000 a month on Claude and began evaluating a local, self-hosted swap to bring that down — real motivation, not proof self-hosting would win the math.
Run the utilization numbers before assuming fixed compute wins. No vendor-claimed self-hosting savings percentage should be treated as fact here — it's the last rung for a reason.
## How do you prove a cost cut didn't hurt quality?
Every lever above needs a quality gate before it's declared a win: a golden eval set, a pass/fail threshold, a latency boundary, a named rollback owner.
Without that gate, "we cut spend 40%" and "we can't prove quality held" are the same sentence — a pattern real teams run into after the fact, not before it. Build the eval set from 50–200 representative tasks pulled from real production traffic, not synthetic examples.
Our guide on [how we benchmark AI models on real work](/blog/how-we-benchmark-ai-models-on-real-work) walks through building that test set instead of trusting leaderboard scores that don't match your workload.
## Frequently asked questions
**What's the difference between reducing LLM cost and just using AI less?**
Reducing LLM cost means lowering the cost of each successful task, not cutting usage indiscriminately. Blunt caps — a common first reaction to a spike — often suppress valuable work. The better lever is removing waste (unused seats, markup, oversized default models) and right-sizing models per task while holding a quality floor.
**Is Claude or GPT cheaper for enterprise use?**
It depends on the task and tier, not the brand. Within OpenAI's own lineup, the spread between GPT-5.4-nano ($0.20/MTok input) and GPT-5.6-sol ($5.00/MTok input) is 25×; within Anthropic's, Haiku 4.5 ($1/MTok) to Fable 5 ($10/MTok) is 10×. The right question isn't "Claude or GPT" — it's which tier of either provider clears your quality floor for this specific task.
**Does prompt caching actually save money, or is it marketing?**
It's a real, provider-documented discount. OpenAI applies a 90% discount to cached input automatically for prompts of 1,024+ tokens, zero code changes. Anthropic offers the same 90% discount on cache reads with one added request field. If your application repeats system prompts or RAG context across calls, which most production LLM apps do, this is available today.
**Should we cap AI spend per user?**
A flat per-user cap is a blunt instrument — it stops catastrophic spend but can also block a power user doing valuable work while a light user's allowance goes to waste. Better guardrails: budget alerts scoped by team or agent, loop limits, and an exception process with a named owner and expiry date.
**Is self-hosting an open-source model cheaper than API pricing?**
Sometimes, but only at sustained high utilization, and never automatically. Open-weight models like DeepSeek V4 Flash ($0.14/MTok input) are dramatically cheaper per token than frontier APIs, but self-hosting adds GPU utilization risk and operations overhead that token pricing doesn't carry. Run the utilization and total-cost math first; it's the last lever to evaluate, not the first.
**How much can enterprises realistically expect to save?**
There's no single honest percentage — it depends on how much of your bill is seat waste, markup, or genuinely necessary frontier-tier work. What's verifiable: right-sizing from a frontier to a mid-tier model can cut that line item by roughly 80%, and caching or batching each cut 50–90% on the tokens they apply to, with zero quality risk. Vendor claims of blanket 30–80% reduction are vendor-modeled, not observed outcomes.
---
Source: https://duet.so/blog/does-chatgpt-claude-train-on-your-data
# Does ChatGPT or Claude Train on Your Data? The Answer Depends on Your Account
*ChatGPT trains on consumer chats unless you opt out; Claude depends on a setting. See exactly what's safe by account type, plus a 5-minute audit.*
By Duet Team. Published 2026-07-18, updated 2026-07-18. 12 min read.
**Quick answer**
ChatGPT trains on consumer content unless you opt out; ChatGPT Business, Enterprise, and API do not train on business data by default. Claude may use consumer chats for training when the model-improvement setting is on; Claude for Work, API, and other commercial services do not train on customer content by default. Feedback and safety-flagged content can still be used under both vendors' policies.
**Questions this page answers**
- Does ChatGPT train on your data by default?
- Does Claude train on your data by default?
- Does ChatGPT Enterprise or Business train on your data?
- Does Claude for Work or the Anthropic API train on your data?
- If training is off, is my data completely private?
- Can my company's admin see what I type at work?
- How do I turn off model training on ChatGPT or Claude?
Checked live against OpenAI and Anthropic's own policy pages on July 17, 2026 — settings and terms change, so verify your own account before you rely on this.
The account you're logged into matters more than which product you picked. Here's the four-row version before the detail:
| Account type | Trains on your content? | Opt-out / control path | Default retention |
| --------------------------------------------------- | --------------------------------------------------------- | ---------------------------------------------------------------------- | ------------------------------------------- |
| ChatGPT Free, Plus, or Pro (personal) | May train — unless you opt out | Settings → Data Controls → "Improve the model for everyone" | Until deleted; 30-day purge after |
| Claude Free, Pro, or Max (personal) | May train — only when the model-improvement setting is on | Settings → Privacy → "Help improve Claude" | 30 days if off; up to 5 years if on |
| ChatGPT Business, Enterprise, or Edu | No training by default | Workspace admin controls retention and access | Deleted conversations purged within 30 days |
| Claude for Work, Enterprise, or either vendor's API | No training by default | Zero data retention for qualifying organizations on eligible endpoints | ~30-day default deletion |
A "no training" row doesn't mean nothing is retained, reviewed, or admin-visible. That's the whole subject of the four-questions section below.
## Does ChatGPT train on your data on a free or paid personal account?
Yes, unless you turn it off. [OpenAI states](https://help.openai.com/en/articles/5722486-how-your-data-is-used-to-improve-model-performance) that content from ChatGPT Free, Plus, and Pro personal accounts may train its models whenever "Improve the model for everyone" is on. That's true across every consumer tier, paid or not.
Paying for Plus or Pro buys you higher usage limits and better models. It doesn't buy you a business data contract. That's a separate product, covered in the next section.
Two carve-outs matter more than the toggle itself. Give a chat a thumbs up or thumbs down, and the entire associated conversation can be used for training, even with the toggle off. Temporary Chat is the one mode never used for training, though OpenAI keeps a safety copy of it for up to 30 days.
| ChatGPT consumer feature | What happens |
| ------------------------ | ------------------------------------------------------------------------- |
| Default chat | May train unless "Improve the model for everyone" is off |
| Thumbs up/down feedback | Trains regardless of the toggle — pulls in the whole conversation |
| Temporary Chat | Never used for training; kept up to 30 days for safety review only |
| Deleted chat | Removed from your history immediately; purged from systems within 30 days |
## Does Claude train on your data on a free or paid personal account?
It depends on a setting you control, not on which plan you pay for. [Anthropic states](https://privacy.claude.com/en/articles/10023580-is-my-data-used-for-model-training) it may use Claude.ai chats and coding sessions — including Claude Code run from a Free, Pro, or Max account — to train its models "only when this setting is on."
Anthropic doesn't publish whether that setting defaults on or off for new or existing consumer accounts. Check it yourself under Settings → Privacy → "Help improve Claude" rather than assume either answer.
If the setting is on, your data can be retained for model training for up to five years. If it's off, standard 30-day back-end deletion applies instead. Either way, explicit feedback and safety-flagged content are still fair game for Anthropic's own trust-and-safety systems.
If you [run Claude Code in the cloud](/blog/how-to-run-claude-code-in-the-cloud) from a personal Claude account, the same consumer training setting follows the coding sessions. It isn't a separate, safer channel.
| Claude consumer feature | What happens |
| -------------------------- | ------------------------------------------------------- |
| Chat, training setting on | May train; can be retained up to 5 years |
| Chat, training setting off | Not used for training; 30-day back-end deletion |
| Thumbs up/down feedback | Stored and usable for training regardless of the toggle |
| Incognito chat | Never used to improve Claude, even with the setting on |
## Does ChatGPT Business, Enterprise, or the API train on your data?
No. By default, OpenAI does not use inputs or outputs from ChatGPT Business, Enterprise, Edu, or the API to train or improve its models.
That's the training answer. The surrounding controls are what make the tier actually usable for company data:
- **Retention:** workspace admins set the retention window; deleted conversations are removed from systems within 30 days.
- **Security posture:** AES-256 encryption at rest, TLS 1.2+ in transit, SOC 2 Type 2, ISO 27001/17/18/27701, GDPR and CCPA support, and a DPA on request.
- **Admin visibility:** Business workspace admins can view, access, export, and delete end-user conversations; Enterprise adds an audit log via the Compliance API.
- **API retention:** 30-day default retention for inputs and outputs, deleted after that unless legally required.
- **Zero data retention:** available on request, for qualifying organizations, on eligible API endpoints only. Not a universal opt-in.
## Does Claude for Work, the API, or Enterprise train on your data?
No. Anthropic does not use Customer Content from its commercial services — Claude for Work, the API, Bedrock, Vertex, Gov, or Education — to train models by default, per both its Privacy Center and its Commercial Terms of Service.
The rest of the picture, at a glance:
- **Carve-outs:** the same feedback and trust-and-safety exceptions that apply to consumer accounts also apply here: explicit feedback and content flagged for safety review remain usable.
- **Retention:** API and commercial data defaults to 30-day auto-deletion.
- **Zero data retention:** a per-organization arrangement on eligible surfaces only, not something any account can self-serve.
## Training, retention, review, and connectors: why "no training" doesn't mean "nothing leaves your business"?
Because "does it train on my data" is really four separate questions bundled into one, and a clean "no" on training doesn't settle the other three.
1. **Training.** Does your content update future model weights? This is the only question a settings toggle actually answers.
2. **Retention.** How long is content stored? Both vendors keep flagged content for up to 2 years, feedback for up to 5 years, and safety-classifier scores for up to 7 years, regardless of your training setting.
3. **Human review.** Can a person read it? Both vendors keep human-review and safety-flag carve-outs that apply "regardless of whether your model training setting is on or off."
4. **Connectors and admins.** Who else can reach it? On a business account, workspace administrators can access and control the account and its content under both vendors' privacy policies. Connected apps and integrations operate under their own separate terms.
A no-training guarantee on your business tier never meant no human, no admin, and no connector would ever touch the data. It meant your content wouldn't retrain the model. Those are different promises.
## What happened when businesses got this wrong?
Two real incidents show what "ungoverned" actually costs — one internal ban, one nine-figure regulatory fine.
Samsung banned staff from using generative AI tools in 2023 after employees pasted sensitive source code and internal data into ChatGPT from personal accounts. The failure wasn't training in the abstract — it was disclosure through a consumer tool with no workspace controls attached.
Italy's data authority took the regulatory route instead. In December 2024, the Garante [fined OpenAI €15 million](https://www.reuters.com/technology/italy-fines-openai-15-million-euros-over-privacy-rules-breach-2024-12-20/) (about $15.58 million) over how it handled personal data and verified users' ages, on top of briefly banning ChatGPT outright the year before.
OpenAI called the fine "disproportionate" and appealed. GDPR fines can reach €20 million or 4% of global turnover, whichever is higher.
Neither case turned on a single training toggle. Both trace back to consumer-tool use with no account-level governance behind it.
## How do you check and fix your settings in five minutes?
Run this five-check audit on your own account before you paste anything you'd regret pasting.
1. **Which account are you actually in?** Personal or company-administered, check the workspace name, not the logo.
2. **Is model improvement on?** ChatGPT: profile icon → Settings → Data Controls → "Improve the model for everyone" (works on web, mobile, and even signed-out sessions, and syncs across devices). Claude: your name → Settings → Privacy → "Help improve Claude."
3. **What's connected?** Review connected apps and connectors, and what each one can actually read.
4. **Who can see your chats?** On a business workspace, your admin can view, export, and delete them.
5. **What's off-limits to paste?** Secrets, credentials, and full customer records, regardless of any toggle's position.
One catch worth remembering: turning a toggle off only stops future use. Anything already pulled into a training run that has already started, or a model that's already been trained, stays as it is.
## What's the safest way to handle business data in ChatGPT or Claude going forward?
Use the approved business or commercial tier for company data, and stop treating a settings toggle as the whole answer.
The operating rules that hold up in practice:
- Do company work in the business/commercial tier, not a personal login. That's the only tier with a no-training default and an admin behind it.
- Never paste secrets, credentials, or full customer records into a personal account, no matter which toggle is set.
- Review connector and connected-app scopes; a no-training vendor promise doesn't extend to whatever a connector can read.
- Keep one governed workspace instead of scattering the same work across personal chat logins. See [who actually runs your AI agent after you build it](/blog/who-runs-your-ai-agent-after-you-build-it) for what happens when nobody owns that upkeep.
That last point is the structural fix, not another checklist. Teams that [build a real AI command center](/guides/how-to-build-your-ai-command-center) stop relitigating "which account was this in?" every single week.
Here's the pattern underneath every version of this question: the risk was never really ChatGPT versus Claude. It's how many personal logins, browser tabs, and unmanaged chat histories your business's actual work is scattered across. A fully compliant, no-training business tier still can't help if an employee pastes a customer list into the personal account they're used to.
The fix isn't a settings checklist to re-run every quarter. It's giving your team one approved, governed AI workspace where data access, retention, and connectors get defined once instead of relitigated per chat.
That's the operating model behind how Duet's own team runs its content work, a persistent workspace instead of ad hoc chat sessions.
## Frequently Asked Questions
### Does ChatGPT train on my data by default?
ChatGPT's consumer plans (Free, Plus, and Pro) train on your content whenever "Improve the model for everyone" is on. OpenAI's help pages walk through how to turn that setting off, but no page states outright that it starts in the on position, so the accurate phrasing is that ChatGPT trains on consumer content unless you opt out.
### Does Claude train on my data by default?
Anthropic doesn't publicly document whether the "Help improve Claude" toggle defaults on or off for consumer accounts. Check Settings → Privacy in your own account to see its current state. What's confirmed: on means chats and coding sessions may train models and can be retained up to five years; off means standard 30-day deletion.
### Does ChatGPT Enterprise or Business train on my data?
No. By default, OpenAI does not use data from ChatGPT Business, Enterprise, Edu, or the API — including inputs and outputs — to train or improve its models.
### Does Claude for Work or the Anthropic API train on my data?
No. Anthropic does not use Customer Content from Claude for Work, the API, Bedrock, Vertex, Gov, or Education services to train models by default, per both the Privacy Center and the Commercial Terms of Service.
### If training is off, is my data completely private?
No. Both vendors keep carve-outs: explicit feedback can still be used, and content flagged for safety or trust review can be retained separately: up to 2 years for the flag and up to 7 years for classifier scores, regardless of your training setting.
### Can my company's admin see what I type into ChatGPT or Claude at work?
Yes, on a business or workspace account. Administrators can access and control the account, including its content, under both OpenAI's and Anthropic's privacy policies. ChatGPT Business specifically lets workspace admins view, export, and delete end-user conversations.
### How do I turn off model training on ChatGPT or Claude?
On ChatGPT: profile icon → Settings → Data Controls → toggle off "Improve the model for everyone." It works on web, mobile, and even signed-out sessions. On Claude: your name → Settings → Privacy → toggle off "Help improve Claude." Turning it off stops future training use; it doesn't undo training runs that already started.
---
Source: https://duet.so/blog/dropshipping-automation-dashboard-ai
# Build a Dropshipping Automation Dashboard with AI
*One dashboard to rule your entire dropshipping operation. Build a fully automated tracking and alert system with AI — no code needed.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 11 min read.
Running a dropshipping business across multiple suppliers, ad platforms, and storefronts without a centralised dashboard is like navigating by looking out the rear window. You're always reacting — to supplier delays, margin erosion, ad spend going off-track — instead of seeing problems before they become expensive.
An automation dashboard built with AI gives you one screen that shows everything in real time: orders, margins, supplier performance, ad spend, inventory levels, and competitor price movements. This guide walks through what your dashboard should track, how to build it without a developer, which platforms integrate cleanly, and how to automate the repetitive ops work so you can focus on scaling.
**Quick Summary**
This guide walks through building an automated dropshipping dashboard using AI — tracking orders, monitoring supplier performance, flagging price changes, and surfacing insights without manual data entry.
**Questions this page answers**
- How to build a dropshipping automation dashboard with AI
- Best AI tools for dropshipping operations
- How to automate dropshipping order management
- Can AI monitor supplier performance for dropshipping?
- How to build a dropshipping dashboard without coding
## SaaS Tabs Killing Your Dropshipping Productivity
Every dropshipping store generates data across multiple disconnected platforms. The problem compounds as you scale.
A typical 2-store operator checks these tools daily:
| Component | Tool | Purpose |
| --------------- | ----------------- | ------------------------- |
| Data collection | Firecrawl | Scrape product/price data |
| Storage | Supabase / SQLite | Store metrics |
| Backend | Python / Node.js | Process & aggregate |
| Frontend | React / Retool | Visualize data |
| Alerts | Slack / Email | Notify on thresholds |
That's $100-500/month in tool subscriptions. But the real cost is attention. Switching between 7 tabs means you spend 1-2 hours daily just gathering data before making a single decision.
Stores using unified automation report 75% higher profits. Full automation enables operating with 57% fewer employees while managing 3.2x more products. The bottleneck isn't strategy — it's the time wasted collecting information.
## Unified Dropshipping Dashboard
A useful dashboard answers six questions without clicking away to another tool.
### The Six Essential Panels
1. **Sales performance.** Revenue, orders, and average order value by store — today, this week, this month. Compare periods. Spot drops before they compound.
1. **Inventory status.** Stock levels across suppliers. Items below reorder threshold. Products marked out-of-stock by suppliers since your last check.
1. **Profit margins.** Real-time margin per product after COGS, shipping, platform fees, and ad spend. Sorted worst-to-best so you see problems first.
1. **Competitor prices.** Side-by-side comparison of your prices vs. top 3 competitors for each product. Highlight where you're undercut by more than 10%.
1. **Supplier health.** Average shipping time, dispute rate, last response time, stock reliability score per supplier. One bad supplier can tank your store rating.
1. **Ad performance.** ROAS, CPA, and daily spend across Google and Meta. Connected to revenue so you see true profitability, not vanity metrics.
Most dropshippers track 2-3 of these. Tracking all six in one view is what separates stores stuck at $10K/month from those breaking $50K.
## Building Dashboard From Plain English
You don't need to write code. Modern AI agents translate natural language descriptions into functional web applications.
### Describe What You Want
Open an AI agent and describe your dashboard in plain English. Be specific about metrics and layout.
Example prompt:
> "Build me a dropshipping dashboard. I run two Shopify stores. I need to see daily revenue and orders for each store, profit margin per product, a table of my top 20 products sorted by margin, a competitor price comparison section, and a chart showing weekly ad spend vs. revenue. Use a dark theme. Add a last-updated timestamp."
### Review the First Build
The AI generates a working dashboard in 3-10 minutes. Check that:
- All six panels display correctly
- Charts render with sample data
- Tables sort and filter as expected
- The design is readable on your monitor
### Iterate
Ask for specific changes. Each round takes under a minute.
- "Add a red badge on products where margin drops below 15%."
- "Make the competitor price table highlight cells where I'm more than $3 above the lowest price."
- "Add a supplier reliability column to the inventory table."
Most dashboards reach a usable state in 3-5 iterations. For a deeper walkthrough on building apps with AI from scratch, see [How to Build and Deploy a Web App Using Only AI](/blog/how-to-build-and-deploy-a-web-app-using-only-ai).
### Deploy
Publish the dashboard to a live URL. Bookmark it. Open it every morning instead of your 7 tabs.
## How To Connect Data Sources?
A dashboard showing sample data is a prototype. Connecting real data makes it operational.
### Shopify API
Shopify provides a REST API exposing orders, products, inventory levels, and fulfillment data. Your AI agent generates the connection code from your credentials.
**What you need:**
- Shopify store URL
- Admin API access token (Settings > Apps > Develop apps)
**Data available:**
- Orders (revenue, items, customer, timestamps)
- Products (title, price, inventory count, variants)
- Fulfillments (shipping status, tracking numbers)
### Scraped Competitor Data
Competitor pricing isn't available via API. It requires web scraping — automated scripts that visit competitor pages and extract prices.
Your AI agent writes the scraper. You provide competitor URLs. The scraper extracts product names, current prices, sale indicators, stock availability, and shipping costs.
For a step-by-step guide, see [How to Build an Automated Dropshipping Price Monitor with AI Alerts](/blog/dropshipping-price-monitor-ai-alerts).
### Supplier Feeds
Most suppliers provide inventory data through CSV exports, API endpoints, or feed URLs.
**Common formats:**
Start with whatever your supplier offers. Automate the pull later.
## Set Up Automated Data Refresh?
Static data goes stale fast. Scheduled tasks (cron jobs) keep your dashboard current without manual work.
### Define Your Refresh Schedule
Different data needs different frequencies:
### Create the Scheduled Tasks
Tell your AI agent to set up each cron job: "Every hour, pull new orders from Shopify. Every 6 hours, scrape competitor prices for my top 20 products. Every Monday at 8 AM, generate a weekly summary of revenue, margins, and competitor price changes."
### Verify It Runs
Check your dashboard after each scheduled interval to confirm fresh data appears. Look at the "last updated" timestamp. If a job fails, the AI logs the error for troubleshooting.
For a complete guide to scheduled AI automation, see [How to Set Up a 24/7 AI Agent That Works While You Sleep](/blog/how-to-set-up-a-24-7-ai-agent).
## Add an AI Insights Layer
A dashboard shows data. An AI insights layer interprets it.
### Asking Your Dashboard Questions
With a persistent AI agent connected to your dashboard data, you can ask questions in plain English:
- "Which products are trending down this week compared to last week?"
- "Which supplier has the worst shipping times this month?"
- "Am I losing money on any products after ad spend?"
- "What's my true profit margin across all stores after returns?"
The AI queries your data, runs the calculations, and returns a direct answer. No spreadsheet exports. No pivot tables.
### Automated Daily Briefing
Schedule a 7 AM briefing that summarizes yesterday's sales, flags products where margin dropped below 15%, lists competitor price changes from the last 24 hours, and highlights supplier stockouts affecting active listings. This replaces the first hour of your day — the one you currently spend clicking through tabs.
### Trend Detection
AI spots patterns humans miss when scanning numbers. Configure alerts for revenue anomalies (sales down 20% vs. same day last week), margin erosion (costs creeping up over 30 days), and demand shifts (order velocity changing on specific SKUs).
## Add Webhook Alerts for Critical Events
Some events can't wait for the next scheduled data pull. Webhooks trigger instant notifications.
### Events Worth Alerting On
### Setting Up Webhook Alerts
Tell your AI agent: "When any competitor price drops more than 15% on my tracked products, send a Slack message to #price-alerts with the product name, old price, new price, and competitor link."
The agent creates the webhook endpoint, writes the notification logic, and connects it to Slack or email. Alerts fire within minutes of detection. For a deeper look, see [How to Set Up AI-Powered Dropshipping Competitor Monitoring](/blog/dropshipping-competitor-monitoring-ai).
## Deploy a Dropshipping Dashboard in 10 Minutes
Here's a ready-to-use prompt. Copy it, paste it into an AI agent, and deploy.
```plaintext
Build a dropshipping operations dashboard with these sections:
1. HEADER: Dashboard title, last-updated timestamp, store selector dropdown
2. KPI ROW (4 cards): Today's revenue (% change vs yesterday), today's orders (% change), average margin, active product count
3. REVENUE CHART: Line chart of daily revenue (30 days) with ad spend overlay and net profit line
4. PRODUCT TABLE: Product name, Price, COGS, Margin %, Orders (7d), Revenue (7d), Competitor Lowest Price, Stock Level — sortable, red rows where margin < 15%, yellow where stock < 10
5. COMPETITOR PANEL: My Price vs 3 competitor prices per product — green when lowest, red when highest
6. SUPPLIER HEALTH: Supplier name, Avg Ship Time, Dispute Rate %, Last Response, Reliability Score — sorted by reliability
7. ALERTS FEED: Scrollable list of stockouts, price changes, margin warnings with timestamps
Design: Dark theme. Primary color: #27C08D. Sans-serif. Mobile-responsive.
Data: Sample JSON initially. I'll connect APIs later.
```
This gives you a working dashboard with sample data. Swap in real API connections as you go. For more on building tools this way, see [How to Build an Internal Tool in a Day with AI](/blog/how-to-build-internal-tool-in-a-day-with-ai).
## Where To Host a Dashboard That Runs 24/7?
A dashboard that refreshes data on a schedule needs a server running around the clock. Your laptop won't cut it, close the lid and your cron jobs stop.
### The Hosting Problem
Fully custom dashboards need a persistent environment: cron jobs running 24/7, web scraping execution, a shareable URL, an AI agent available for questions, and API connections that stay authenticated. Self-hosting on a VPS (DigitalOcean, AWS) works but requires server management, updates, monitoring, restarts when things break. For someone who got into dropshipping to avoid technical overhead, that defeats the purpose.
### A Simpler Approach
[Duet](/) combines app hosting, a persistent AI agent, cron scheduling, and integrations (including Shopify) in one platform. Describe your dashboard in conversation, the AI builds it, and Duet hosts it on a live URL with scheduled data refreshes running in the background. The AI agent stays connected to your data, so you can ask it questions anytime — "What was my best-performing product last week?" — and get an answer from live numbers.
No server management. No switching between tools to check data. Your dashboard, your cron jobs, and your AI agent all run in one place.
## Frequently Asked Questions
### How much does it cost to build a custom dropshipping dashboard?
Using AI to build the dashboard costs nothing beyond your AI tool subscription. Hosting and data refresh typically runs $20-50/month. Compare that to $100-500/month on 5-7 separate SaaS tools that each show only a slice of your operation. Most operators save money by consolidating.
### Do I need coding skills to connect Shopify to my dashboard?
No. AI agents generate the Shopify API connection code from your store URL and API token. You paste in credentials, the AI handles authentication and data fetching. If the connection breaks, describe the error and the AI fixes it.
### How often should my dashboard data refresh?
Sales and orders: every hour. Competitor prices: every 4-6 hours (more frequent risks getting blocked). Inventory: every 4 hours. Ad performance: twice daily. Weekly rollups: Monday morning. Adjust based on how fast your market moves.
### Can one dashboard handle multiple Shopify stores?
Yes. Add a store selector dropdown. Each store connects via its own API credentials. The AI aggregates data across stores for total revenue, combined inventory, and cross-store margin analysis. Operators running 2-5 stores see the biggest time savings from consolidation.
### What happens when a competitor changes their website layout and scraping breaks?
Scrapers depend on page structure. When a competitor redesigns, the scraper may return empty data. Your dashboard should show a "last successful scrape" timestamp per competitor. When you notice stale data, tell your AI agent: "The scraper for [competitor URL] is broken. Fix it." The agent inspects the new page structure and updates the scraper.
### Is web scraping competitor prices legal?
Publicly displayed prices are generally fair game. Avoid scraping behind logins, bypassing CAPTCHAs, or hitting sites so frequently you disrupt service. Keep intervals reasonable (every 4-6 hours, not every minute). Check target terms of service. This is standard practice — Prisync, Priciq, and every major price monitoring tool do the same thing.
### Can I share this dashboard with my VA or business partner?
Yes. Deploy to a public URL and share the link. For sensitive data, add password protection. Some operators create separate views — a summary for partners and a detailed view for daily operations. The AI builds both from the same data source.
---
---
Source: https://duet.so/blog/dropshipping-competitor-monitoring-ai
# AI-Powered Dropshipping Competitor Monitoring Setup
*See every move your competitors make before it hits your sales. Set up automated dropshipping competitor monitoring with AI.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 13 min read.
Your competitors are making moves every day — new products, price changes, ad creative shifts, stock fluctuations — and most of those moves are completely visible if you're looking at the right signals. The problem is that looking at those signals manually, across multiple competitors, across multiple platforms, isn't realistic at any scale.
AI-powered competitor monitoring makes it realistic. You define the competitors, the signals, the platforms, and the alert thresholds — and an AI agent watches everything continuously, surfacing what matters when it matters. This guide covers exactly how to set it up for a dropshipping business, which signals actually drive decisions, and how to turn competitive data into a genuine operational edge.
**Quick Summary**
This guide covers how to set up an AI-powered competitor monitoring system for dropshipping — tracking competitor product listings, pricing, promotions, and new arrivals automatically so you can react faster than the competition.
**Questions this page answers**
- How to monitor dropshipping competitors with AI
- Best AI tools for dropshipping competitor analysis
- How to automate competitor product tracking for dropshipping
- Can AI monitor competitor stores automatically?
- How to stay ahead of competitors in dropshipping with AI?
## Why Does Competitor Intelligence Separate 6-Figure From 7-Figure Stores?
The difference between a $100K store and a $1M store is rarely product selection alone. It is speed of response.
| Task | Tool | Output |
| ---------------- | -------------- | --------------- |
| Store scraping | Firecrawl | Product JSON |
| Change detection | Python difflib | Delta report |
| AI analysis | Claude | Insight summary |
| Alerts | Slack webhook | Daily digest |
| Storage | Supabase | Historical data |
When a competitor copies your winning product and undercuts by $3, you have 48-72 hours before your ad performance craters. Manual monitoring — checking stores, scrolling Facebook Ad Library, comparing prices in spreadsheets — cannot keep up.
The math is brutal:
Stores running AI-driven competitor research achieve 67% lower customer acquisition costs. Products chosen with AI analysis are 50% more likely to become bestsellers within 90 days.
The operators who win are not checking competitors manually. They built a system that watches for them.
## What Should You Track About Your Competitors?
Not every competitor action matters. Track the five signals that directly affect your revenue.
1. New product launches
When a competitor adds a product in your niche, you need to know within 24 hours. Late discovery means they capture organic rankings and ad momentum before you can respond.
2. Price changes
A $2 price drop on a shared product can shift 30-40% of ad traffic to the cheaper listing. Track exact prices, not ranges.
3. Bestseller movements
Which products are climbing their collections? Which ones disappeared? Bestseller shifts reveal what is actually selling versus what they are testing.
4. Ad creatives
New creatives in Meta Ad Library or TikTok Creative Center signal product pushes. High-spend creatives indicate validated winners.
5. Store structure changes
New collections, homepage hero changes, and navigation updates reveal strategic pivots. A competitor adding a "Summer Collection" in March means they are planning seasonal inventory.
Track these data points per competitor:
- Total product count
- New products added (last 7 days)
- Products removed (last 7 days)
- Price changes on overlapping SKUs
- Homepage featured products
- Active ad creatives (count and themes)
## How To Build a Competitor Scraping System?
Automated scraping collects the raw data. Three sources cover most of what you need.
### Scraping Shopify Stores
Every Shopify store exposes a public JSON endpoint. This is the easiest data source in ecommerce.
Step 1: Access the product feed
Append /products.json to any Shopify store URL:
```plaintext
https://competitor-store.com/products.json?limit=250&page=1
```
This returns product titles, prices, variants, images, creation dates, and tags. No authentication needed.
Step 2: Paginate through the full catalog
Most stores have fewer than 1,000 products. Loop through pages until you get an empty response:
```javascript
let page = 1
let allProducts = []
while (true) {
const res = await fetch(`https://competitor.com/products.json?limit=250&page=${page}`)
const data = await res.json()
if (data.products.length === 0) break
allProducts.push(...data.products)
page++
}
```
Step 3: Extract the signals that matter
From each product, pull:
- title and handle (for identification)
- variants[0].price (current price)
- created_at (to detect new launches)
- published_at (to catch republished products)
- tags (niche and category signals)
Step 4: Store snapshots with timestamps
Save daily snapshots as JSON files. Compare today's catalog against yesterday's to detect additions, removals, and price changes.
### Monitoring Social Ad Libraries
Meta Ad Library provides public access to active ads. Track number of active creatives per competitor, launch dates, creative themes (image vs. video, UGC vs. studio), and destination URLs showing which products they are pushing.
TikTok Creative Center surfaces top-performing ads by category. Filter by your niche and monitor weekly.
### Tracking Bestseller Rankings
Append ?sort_by=best-selling to Shopify collection URLs, then scrape product order. Position changes over time reveal demand shifts. For stores that hide sort order, track homepage and email features — featured products correlate strongly with sales volume.
## Raw Data Into Weekly Strategic Briefings
Raw product feeds and price lists are not intelligence. AI analysis turns data into decisions.
Step 1: Structure the change log
After each scrape, generate a structured diff:
```json
{
"competitor": "RivalStore",
"period": "2026-02-24 to 2026-03-01",
"new_products": [{ "title": "LED Sunset Lamp V3", "price": 24.99, "added": "2026-02-26" }],
"removed_products": [{ "title": "LED Sunset Lamp V1", "last_seen": "2026-02-25" }],
"price_changes": [{ "title": "Posture Corrector Pro", "old_price": 29.99, "new_price": 22.99 }],
"bestseller_shifts": ["Ring Light Kit moved from #8 to #3"]
}
```
Step 2: Feed the diff to an AI model
Prompt the model with your business context:
```plaintext
You are a competitive intelligence analyst for a dropshipping business
selling home gadgets and wellness products.
Analyze this week's competitor changes:
[change log]
Answer:
1. Which new products pose the biggest threat to our catalog?
2. Do any price drops signal a price war we need to respond to?
3. What product trends are emerging based on launches and bestseller shifts?
4. What specific actions should we take this week?
Keep answers under 200 words total. Be direct.
```
Step 3: Generate a formatted briefing
The AI output becomes your Monday morning intelligence report. Structure it as:
This replaces 6-8 hours of manual competitor research with a 5-minute read.
## Automate Reports With Cron Scheduling
Cron jobs run your scraping and analysis on a fixed schedule without manual intervention.
Step 1: Schedule daily scraping
Run the product scraper every morning at 6 AM:
```bash
0 6 * * * /usr/bin/node /scripts/scrape_competitors.js >> /logs/scraper.log 2>&1
```
This captures product catalog snapshots before you start your workday.
Step 2: Schedule weekly AI analysis
Run the AI briefing generator every Monday at 7 AM:
```bash
0 7 * * MON /usr/bin/node /scripts/generate_briefing.js >> /logs/briefing.log 2>&1
```
The briefing job pulls the last 7 days of snapshots, generates diffs, sends them to the AI model, and formats the output.
Step 3: Deliver the report
Send the formatted briefing via email or webhook:
```javascript
await fetch(SLACK_WEBHOOK_URL, {
method: 'POST',
body: JSON.stringify({
text: `*Weekly Competitor Intel — ${dateRange}*\n\n${briefing}`,
}),
})
```
A typical Monday morning report might include:
- "RivalStore launched 3 new LED products this week, all priced $2-4 below your equivalents"
- "CompetitorX dropped Posture Corrector Pro from $29.99 to $22.99 — likely clearing inventory or testing demand elasticity"
- "Two competitors added 'car accessories' collections — possible emerging niche worth evaluating"
- "Action: Reprice LED Sunset Lamp to $22.99 to match. Evaluate car accessories suppliers by Friday"
You wake up Monday morning, read the briefing over coffee, and know exactly what happened in your market last week. No spreadsheets. No manual store visits.
## Set Up Real-Time Alerts via Webhooks
Weekly reports cover strategic shifts. Some events demand immediate action.
Configure webhook alerts for these triggers:
Implementation:
After each scrape, check the diff against your alert rules:
```javascript
function checkAlerts(diff) {
// Price war trigger
for (const change of diff.price_changes) {
const dropPercent = (change.old_price - change.new_price) / change.old_price
if (dropPercent > 0.1) {
sendAlert(
`PRICE WAR: ${change.title} dropped ${(dropPercent * 100).toFixed(0)}% at ${diff.competitor}`,
)
}
}
// New competing product
for (const product of diff.new_products) {
if (matchesYourNiche(product.tags)) {
sendAlert(`NEW THREAT: ${diff.competitor} launched "${product.title}" at $${product.price}`)
}
}
}
```
Route alerts to Slack, email, or SMS depending on severity. Price wars go to SMS. New products go to Slack. Weekly digests go to email.
The goal is hearing about competitive threats before your ad performance tells you something is wrong.
## Use Intelligence to Stay Ahead
Data without action is a hobby. Here is how to turn competitor intelligence into revenue.
### Product launch timing
When your system detects a competitor testing a new product (low ad spend, single creative), you have a 2-3 week window. If the product aligns with your niche:
1. Source it from your supplier immediately
1. Create ad creatives before they scale
1. Launch at a competitive price point on day one
You enter the market alongside them instead of chasing them 3 weeks later.
### Pricing strategy
Use competitor price data to set strategic positions:
- Price matching — Match the lowest price when margins allow (above $5 net profit)
- Premium positioning — Price 15-20% above competitors when your reviews, branding, or bundle justify it
- Undercutting — Temporarily price $1-2 below a competitor to capture market share during their product launch phase
Dynamic pricing tools increase margins by an average of 23%. Automated monitoring makes dynamic pricing possible.
### Niche selection
Track product launches across 10-15 competitor stores over 60-90 days. When three or more stores add products in the same category within a month, that is a validated trend. Enter before the fourth competitor does.
When competitors start removing products from a category, exit before inventory costs eat your margin.
## Why Do Generic Tools Break?
Most competitor tracking solutions are built for SaaS companies watching pricing pages. Dropshipping monitoring has different requirements.
The problems with generic tools:
- Price monitoring SaaS ($50-200/month): Tracks individual URLs, not full product catalogs. Prisync and Priciq work for 20 SKUs, not 500.
- Browser extensions: Require your laptop to be open. They stop when you close Chrome.
- Spreadsheet workflows: Manual data entry cannot scale past 3 competitors.
- Basic web scrapers: Run once, then break when the store changes themes. No analysis, no alerts, no persistence.
Dropshipping competitor monitoring needs three things generic tools lack: full catalog scraping (not individual URLs), persistent execution that runs without your laptop, and AI analysis that turns product data into strategic recommendations.
A cloud-based server with cron scheduling, web scraping, and AI analysis solves all three. Duet provides this as a single environment — a persistent server where you can set up scrapers, schedule them on cron, run AI analysis on the results, host a competitor dashboard, and configure webhook alerts. Instead of stitching together 4-5 separate services, the entire competitor intelligence pipeline lives in one place. Build once, and it runs on autopilot.
## While Competitors React, You Anticipate
Every dropshipper in your niche makes decisions based on what they notice. They spot a competitor's new product when it shows up in their Facebook feed. They discover a price cut when their ROAS drops.
You are operating on a different timeline.
Your system scraped that product launch 6 hours after it went live. Your AI flagged the price cut before your next ad cycle. Your weekly briefing identified the niche trend from catalog data across 12 stores — two weeks before the first YouTube video about it.
The cost of building this system is a few hours of setup. The cost of not building it is measured in lost sales, wasted ad spend, and missed opportunities every single week.
Stores using automation manage 3.2x more products with 57% fewer employees. The operators who automate competitor intelligence do not work harder. They see further.
## Frequently Asked Questions
How many competitors should I monitor for dropshipping?
Start with 5-8 direct competitors — stores selling the same product categories to the same audience. Add 2-3 adjacent stores in related niches for trend detection. More than 12 stores creates data overload without proportional insight. Focus depth over breadth: track full catalogs for your top 5 rivals, and only monitor new product launches for the rest.
Is it legal to scrape competitor Shopify stores?
Scraping publicly accessible data is generally legal in the US under the hiQ v. LinkedIn precedent (2022). Shopify's /products.json endpoint is public and unauthenticated. Respect rate limits (1-2 requests per second), do not bypass authentication or access private data, and follow robots.txt directives. Consult a lawyer if you plan to republish scraped data commercially rather than using it for internal competitive analysis.
How much does an automated competitor monitoring system cost to run?
Expect $20-60 per month total. A persistent cloud server for running scrapers and cron jobs costs $10-30/month. AI API calls for weekly analysis run $5-15/month depending on competitor count. Firecrawl or similar scraping APIs cost $0-29/month for the volume most dropshippers need. Compare that to Prisync at $99-399/month or manual monitoring at 6-8 hours per week of your time.
Can I monitor non-Shopify competitor stores?
Yes, but the method changes. Shopify stores expose /products.json for easy extraction. For WooCommerce, BigCommerce, or custom stores, use a web scraping tool like Firecrawl or Playwright to extract product data from rendered HTML pages. AI-powered extraction handles varying page structures without custom CSS selectors. The analysis and alerting pipeline remains identical regardless of the source platform.
How quickly should I respond to a competitor's price drop?
Within 48 hours for products where you directly overlap. A 10%+ price drop on a shared product will affect your ad performance within 2-3 days as the algorithm favors cheaper listings. Do not always match — sometimes a competitor is clearing inventory and will raise prices again. Your AI briefing should distinguish between strategic repricing (sustained change with ad support) and tactical clearance (temporary drop with no new creatives).
What if my competitors start monitoring me back?
They probably already are, or they will eventually. This is not a reason to avoid monitoring — it is a reason to be first. The advantage goes to whoever acts on intelligence faster. Focus on response speed rather than secrecy. Keep your winning product testing in unlisted collections. Use different store names for test products. The real moat is your analysis pipeline and decision speed, not the data itself.
How do I measure whether competitor monitoring is actually working?
Track three metrics over 90 days. First, response time to competitive threats — how many hours between a competitor's price change and your counter-move (target: under 48 hours). Second, product launch success rate — are products chosen with competitive intelligence data performing better than blind picks (target: 50%+ improvement). Third, margin protection — are you maintaining margins despite competitor price pressure (target: less than 5% margin erosion per quarter). If all three improve, the system is paying for itself.
---
Source: https://duet.so/blog/dropshipping-price-monitor-ai-alerts
# Build a Dropshipping Price Monitor with AI Alerts
*Never get undercut again. Build a live price monitor with instant AI alerts so you're always the lowest price that matters.*
By Duet Team. Published 2026-03-01, updated 2026-04-19. 12 min read.
In dropshipping, your competitor changing their price by 15% overnight isn't a footnote — it's the difference between a profitable campaign and a wasted ad budget.
If you're checking prices manually, you're always a step behind.
By the time you notice the change, they've already captured the demand at the better price point.
An AI price monitor runs continuously in the background, tracks exactly the products and competitors you care about, and alerts you the moment something meaningful changes.
This guide covers how to build one, what data to track beyond just price, how to automate price responses, and how to handle the edge cases that make simple monitoring tools fail.
**Quick Summary**
This guide shows how to build an AI-powered price monitor for your dropshipping business — tracking competitor prices, alerting you to changes, and keeping you competitive automatically without manual checking.
**Questions this page answers**
- How to build a dropshipping price monitor with AI
- Best AI tools for dropshipping price tracking
- How to automate competitor price monitoring for dropshipping
- Can AI alert me when competitor prices change?
- What is the best way to monitor dropshipping prices automatically?
Dropshipping price monitoring through automated scraping and AI analysis protects your margins by tracking competitor prices in real time.
Stores using dynamic pricing based on automated competitor data see an average 23% margin improvement. A custom price monitor scrapes competitor listings, stores historical data, runs AI trend analysis, and sends instant alerts when prices shift.
## Price Monitoring as Margin Protector?
Because your competitors change prices 2-3 times per week, and every hour you sell below market or above competitor pricing costs you revenue. A single unnoticed $5 price drop from a competitor on a high-volume SKU can cost $500+ in lost sales within days.
Here's what unmonitored pricing actually costs:
Stores that implement automated dropshipping competitor analysis and dynamic repricing see measurable results:
| Scenario | Recommended Response | Timing |
| --------------------------- | ----------------------------- | -------------- |
| Competitor drops price 5% | Match if margin allows | Within 4 hours |
| Competitor drops price 20%+ | Review product viability | Next day |
| You're 10%+ above market | Lower price or add value | Same day |
| Competitor out of stock | Consider small price increase | Within 2 hours |
- 23% average margin improvement with dynamic pricing responses
- 94% reduction in pricing errors from automated processing
- 75% of stores using automation report higher overall profits
Manual price checking across 50-200 SKUs takes 3-6 hours daily. That time has a direct dollar cost, and humans miss changes that happen overnight or on weekends.
## What's Wrong with Existing Price Monitoring Tools?
They're expensive, rigid, and don't integrate with your specific workflow. Most dropshippers outgrow them within months.
The main options and their limitations:
The real problems with these tools:
- No custom logic. You can't say "alert me only if Competitor A drops below my cost + 15%."
- Limited sources. Most track Amazon or Shopify. Few handle eBay, Walmart, or niche supplier sites.
- No AI layer. They report price changes. They don't predict trends or recommend optimal responses.
- Walled data. Getting pricing data into your own spreadsheets, dashboards, or repricing logic requires manual exports.
A custom-built monitor costs $20-100/month to run and does exactly what you need. If you've already explored automating your product research pipeline, adding price monitoring is the natural next step.
## Custom Price Monitor Architecture
Four components connected in a pipeline: scraper, storage, AI analyzer, and alert system.
```plaintext
Competitor URLs → Scraper (hourly cron)
↓
JSON/CSV Storage
↓
AI Trend Analyzer
↓
Webhook Alerts (Slack/Email)
```
Component breakdown:
1. Scraper - Fetches competitor product pages using Firecrawl or Puppeteer. Extracts price, title, stock status, and shipping cost.
1. Storage - JSON files or SQLite database storing timestamped price snapshots. One row per SKU per check.
1. AI Analyzer - Runs on each new data batch. Detects trends, calculates velocity of price changes, flags anomalies.
1. Alert System - Webhook calls to Slack, Discord, or email when prices cross your defined thresholds.
Each component runs independently. The scraper writes data. The analyzer reads it. Alerts fire based on analyzer output. If one breaks, the others keep working.
For the foundational scraping techniques, see how to scrape, analyze, and monitor any website.
## How Do You Build the Price Scraper?
Start with a target URL list and a structured extraction script. The scraper needs to handle three different store types: Amazon, eBay, and Shopify competitor stores.
Step 1: Create your competitor URL list.
```json
{
"competitors": [
{
"name": "CompetitorA",
"platform": "shopify",
"urls": [
"https://competitor-a.com/products/widget-pro",
"https://competitor-a.com/products/widget-lite"
]
},
{
"name": "CompetitorB",
"platform": "amazon",
"urls": ["https://amazon.com/dp/B0XXXXXXXX", "https://amazon.com/dp/B0YYYYYYYY"]
}
]
}
```
Step 2: Write the extraction logic.
Use Firecrawl for structured scraping. It handles JavaScript rendering, which is critical for Shopify stores that load prices dynamically.
```javascript
async function scrapePrice(url, platform) {
const page = await firecrawl.scrapeUrl(url, {
formats: ['extract'],
extract: {
schema: {
type: 'object',
properties: {
price: { type: 'number' },
compareAtPrice: { type: 'number' },
inStock: { type: 'boolean' },
shippingCost: { type: 'number' },
title: { type: 'string' },
},
},
},
})
return {
...page.extract,
url,
platform,
timestamp: new Date().toISOString(),
}
}
```
Step 3: Store results with timestamps.
Append each scrape result to a JSON lines file or SQLite table. Keep every historical data point. You need the history for trend analysis.
```javascript
function storeResult(result) {
const line = JSON.stringify(result) + '\n'
fs.appendFileSync('price-data.jsonl', line)
}
```
Step 4: Handle anti-scraping measures.
- Rotate user agents on each request
- Add 2-5 second delays between requests to the same domain
- Use Firecrawl's built-in proxy rotation for Amazon (which blocks aggressively)
- Cache pages locally to avoid redundant fetches during development
For 50-200 SKUs across 3-5 competitors, expect each full scrape cycle to take 5-15 minutes depending on delays and page load times.
## How Do You Set Up Cron-Based Monitoring?
Schedule the scraper to run at fixed intervals using a cron job on a persistent server. Hourly checks catch most competitive moves. Daily summary reports give you the big picture.
Recommended schedule:
Cron configuration example:
```plaintext
# Hourly price scrape
0 * * * * node /app/scraper/run.js
# Daily summary at 8 AM
0 8 * * * node /app/reports/daily-summary.js
# Weekly trend analysis on Monday
0 9 * * 1 node /app/reports/weekly-trends.js
```
The critical requirement: your cron runner must be on a machine that stays online 24/7. Local machines sleep. Laptop lids close. Cloud servers don't. Setting up a 24/7 AI agent that runs your monitoring scripts on schedule solves the uptime problem.
Store at least 90 days of pricing history. Patterns emerge over 30-60 day windows that you'll miss with shorter retention.
## How Does AI Analysis Detect Trends?
Feed your stored pricing data to an LLM with a structured prompt. The AI identifies patterns that spreadsheet formulas miss: gradual margin squeezes, coordinated competitor moves, seasonal pre-positioning.
What AI analysis catches that rules-based alerts miss:
- Slow-drip price drops. Competitor lowers price by $0.50 every 3 days. Each change is below your alert threshold. The AI spots the trajectory.
- Coordinated moves. Two competitors drop the same SKU within 24 hours. Signals a supplier price decrease you should act on.
- Pre-sale positioning. Competitor raises prices 2 weeks before a known sale event to make the "discount" look larger.
- Stock-based pricing. Competitor raises prices when stock gets low. AI identifies the stock-price correlation.
Example AI analysis prompt:
```plaintext
Analyze these price changes for SKU "widget-pro" over the last 30 days:
[pricing data array]
Identify:
1. Price trend direction and velocity
2. Any pattern in timing of changes
3. Competitor likely next move
4. Recommended price for my listing (my cost: $12.50, target margin: 30%)
```
The AI returns actionable recommendations, not just data. "Competitor A has dropped price 4 times in 14 days, averaging $1.20/drop. Likely to reach $22 within a week. Recommend holding at $24.99 until they stabilize, then match at $23.49 to maintain 28% margin."
For a deeper look at building AI-powered competitive intelligence pipelines, the same techniques apply directly to pricing.
## How To Set Up Webhook Alerts for Instant Notifications?
Configure outbound webhooks that fire when your analyzer detects a price event worth acting on. Slack and email are the two most practical channels for dropshippers.
Step 1: Define your alert thresholds.
```javascript
const alertRules = [
{ type: 'price_drop', threshold: 5, unit: 'percent' },
{ type: 'undercut', description: 'competitor below my price' },
{ type: 'out_of_stock', description: 'competitor SKU unavailable' },
{ type: 'new_competitor', description: 'new listing for tracked SKU' },
{ type: 'trend_alert', description: 'AI detects sustained downward trend' },
]
```
Step 2: Send structured Slack notifications.
```javascript
async function sendSlackAlert(alert) {
await fetch(SLACK_WEBHOOK_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
text: `Price Alert: ${alert.sku}`,
blocks: [
{
type: 'section',
text: {
type: 'mrkdwn',
text:
`*${alert.type}* - ${alert.sku}\n` +
`Competitor: ${alert.competitor}\n` +
`Old: $${alert.oldPrice} → New: $${alert.newPrice}\n` +
`Your price: $${alert.yourPrice}\n` +
`Recommended action: ${alert.recommendation}`,
},
},
],
}),
})
}
```
Step 3: Add email fallback for critical alerts.
Slack is fast but easy to miss. For undercuts on your top 10 SKUs, send email too. Use a simple SMTP integration or a service like SendGrid (free tier: 100 emails/day).
Response time matters. A 30-minute delay in reacting to a competitor price drop during peak hours costs more than a 30-minute delay at 3 AM. Weight your alert urgency by time of day and SKU revenue ranking.
## How Does the Cost Compare: Custom Build vs. Prisync vs. Manual?
Custom monitoring is 60-90% cheaper than SaaS tools and infinitely more flexible than manual tracking.
The breakeven is fast. At 100+ SKUs, you save $100-180/month over Prisync. At 500+ SKUs, the savings are $200+/month because SaaS tools charge per-SKU tiers while your custom scraper costs the same whether it tracks 50 or 5,000 URLs.
The real value is in the AI layer and custom logic. No off-the-shelf tool lets you write rules like "if Competitor A drops below $X AND their stock is above Y units, alert me immediately, otherwise ignore." Your custom build does.
You can visualize all of this in a custom dashboard. Here's how to build and deploy a web app using AI to create a pricing dashboard for your store.
## Where Does a Cloud-Based AI Agent Fit In?
The scraper, cron jobs, and AI analysis all work on your local machine during testing. In production, they break.
Common failure points:
- Your laptop sleeps and misses the 2 AM price check that would have caught a competitor's overnight sale
- A scraper error at 6 PM Friday goes unnoticed until Monday
- The AI analysis needs 3-5 minutes of compute per run, and your local machine is doing other things
- Cron jobs stop when you close your terminal
You need a persistent cloud server that runs 24/7, executes cron jobs reliably, and can run AI analysis on schedule without your machine being online. The server needs to handle web scraping (with Firecrawl), file storage for price history, LLM calls for analysis, and outbound webhooks for alerts.
Duet provides this as an always-on cloud environment. You describe the scraping, analysis, and alert logic. Duet runs it on a persistent server with cron scheduling, Firecrawl for scraping, AI analysis built in, and webhook support for Slack and email notifications. No infrastructure management. The monitoring setup for competitor tracking covers the specific configuration.
## Frequently Asked Questions
### How often should I check competitor prices for dropshipping?
Check prices every 1-2 hours for your top 20% of SKUs by revenue and every 4-6 hours for the rest. Hourly monitoring catches most competitive moves within a reasonable window. More frequent checking (every 15 minutes) is unnecessary for most dropshipping niches and increases scraping costs and detection risk.
### Is it legal to scrape competitor prices?
Scraping publicly visible pricing data is generally legal in the United States under the hiQ v. LinkedIn precedent. You're accessing the same information any customer sees. Avoid scraping behind logins, bypassing CAPTCHAs through deceptive means, or violating a site's Terms of Service. Consult a lawyer for your specific jurisdiction and use case.
### How many SKUs can a custom price monitor handle?
A well-built scraper with proper rate limiting handles 1,000-5,000 SKUs comfortably on a single server. At 5-second delays between requests, 1,000 URLs take about 83 minutes per full cycle. Parallel scraping across different domains reduces this to 20-30 minutes. Beyond 5,000 SKUs, add distributed workers.
### What's the minimum budget to start automated price monitoring?
You can start for $20-50/month. A basic cloud server costs $5-20/month. Firecrawl's free tier covers 500 pages/month. An LLM API for analysis runs $5-15/month at moderate usage. Slack webhooks are free. The main investment is 8-12 hours of initial setup time building the scraper and alert logic.
### Can I automate repricing based on competitor data?
Yes, but add safeguards. Set absolute floor prices (never below cost + 10%), maximum daily price changes (no more than 2 adjustments per SKU per day), and human approval for changes above 15%. Fully automated repricing without guardrails leads to price wars. Start with alert-and-suggest before enabling auto-reprice.
### How do I handle competitors with anti-scraping protections?
Use a scraping service like Firecrawl that includes proxy rotation and JavaScript rendering. For heavily protected sites like Amazon, residential proxies reduce block rates to under 5%. Rotate user agents, add human-like delays (2-8 seconds), and avoid scraping during the target site's peak hours. If a site blocks consistently, switch to their official API if one exists.
### What data should I track beyond just the price?
Track shipping cost, stock availability, seller rating, number of reviews, and any active coupon codes or promotions. A competitor's listed price means nothing if they're offering free shipping and you're charging $5.99. The total landed cost to the customer is what determines competitiveness. Stock levels also signal when a competitor is about to run out, creating an opportunity to raise your price.
---
Source: https://duet.so/blog/duet-vs-claude-for-small-business
# Duet vs Claude for Small Business: Which AI Runs Your Workflows in 2026?
*Anthropic's Claude for Small Business vs Duet compared on workflows, integrations, pricing, and setup. Which AI actually runs your business?*
By Duet Team. Published 2026-05-15. 11 min read.
**Quick Summary**
Anthropic launched [Claude for Small Business](https://www.anthropic.com/news/claude-for-small-business) on May 13, 2026, with 15 prebuilt workflows and direct connectors into QuickBooks, HubSpot, Google Workspace, and Microsoft 365. Duet takes the opposite shape: instead of bolting AI into each SaaS tool, it gives your team a private cloud workspace with a persistent AI teammate that spans every tool, builds its own apps, and runs scheduled work in the background.
- **15-person HVAC business that lives in QuickBooks and HubSpot:** Claude for Small Business.
- **Agency running repeatable client workflows across many tools:** Duet.
- **Owner who wants AI inside the SaaS they already pay for:** Claude for Small Business.
- **Team that wants one named AI coworker with memory, files, and cron:** Duet.
**Questions this page answers**
- Is Claude for Small Business better than Duet?
- What is Claude for Small Business and what does it include?
- Does Duet work with QuickBooks and HubSpot?
- Can I run Claude Code or Codex inside Duet?
- Which is cheaper for a 10-person team?
- Can I use both Duet and Claude for Small Business?
## What Anthropic Just Launched
On May 13, 2026, Anthropic announced [Claude for Small Business](https://www.anthropic.com/news/claude-for-small-business), positioning Claude as a packaged AI assistant for non-technical owners. The launch was covered by [Axios](https://www.axios.com/2026/05/13/anthropic-claude-small-business) and [TechCrunch](https://techcrunch.com/2026/05/13/anthropic-claude-small-business-launch/) and included a 10-city in-person tour kicking off in Chicago on May 14.
The product ships with:
- **Direct connectors** into QuickBooks, PayPal, HubSpot, Canva, Docusign, Google Workspace, and Microsoft 365.
- **15 prebuilt workflows** covering bookkeeping prep, invoice chasing, lead follow-up, contract review, and basic marketing tasks.
- **15 prebuilt skills** packaged by Anthropic, with "human approval required" gates on outbound actions.
- **Claude Team and Enterprise pricing** as the underlying billing surface.
The framing is sharp: AI as a toggle inside the SaaS you already pay for. You open QuickBooks, you click a Claude button, the workflow runs.
## What Duet Is
[Duet](/) is a cloud agent workspace. Each workspace gets a dedicated cloud VM for persistent AI work. Durable session events show the assignment, progress, questions, and results, while Files, Train, Integrations, and Apps hold the supporting workspace state.
The core wedge is **Build and Run**. Lovable builds you an app and leaves. Duet builds you an app and runs it. Your AI coworker shows up tomorrow with full memory of yesterday, the files it created, the integrations you connected, and the scheduled jobs you set up.
Concretely, every Duet workspace gets:
- A dedicated cloud VM with a full development toolchain.
- Persistent file storage that survives sessions.
- Cron scheduling for recurring work like daily reports or weekly newsletters.
- Shared Files for reusable instruction playbooks and Train for durable business context.
- Hosting for any web app the agent builds, with [custom domains](/blog/custom-domain-names-in-duet) supported.
- Multi-model routing across Claude, GPT, Gemini, and xAI under one workspace.
## The Core Philosophy Difference
This is the cleanest way to think about the choice.
**Claude for Small Business is AI as a toggle inside existing SaaS tools.** It assumes your business already runs on QuickBooks, HubSpot, and Google Workspace, and the right place for AI is inside those products. Anthropic curates 15 workflows and 15 skills, you pick from the menu, and Claude runs them with approval gates.
**Duet is AI as a named teammate with an ID card and persistent workspace.** You hire it, give it access to the tools you use, and it spans them all. It is not a feature inside QuickBooks. It is a coworker that opens QuickBooks when it needs to, opens Notion when it needs to, writes a Python script when none of the above will do, and remembers what happened last week.
Both shapes are valid. They serve different teams.
## Side by Side
| Dimension | Claude for Small Business | Duet |
| --------------------- | ---------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
| Setup | Sign up to Claude Team or Enterprise, connect SaaS tools, pick a prebuilt workflow | Sign up, connect tools through managed integrations, give your AI coworker its first job |
| Where it lives | Inside the Claude product, alongside your existing SaaS | A private cloud workspace with sessions, files, apps, and integrations |
| Integrations approach | Curated first-party connectors (QuickBooks, HubSpot, Google, MS 365, etc.) | Open managed connector layer plus custom code the agent writes itself |
| Workflows | 15 prebuilt, Anthropic-curated | Open-ended work recorded in durable sessions, files, and apps |
| Reusable context | 15 prebuilt skills with human approval | Shared Files for instructions and Train for durable business sources |
| Persistence | Per-conversation context, account-level memory | Persistent server, files, memory, cron jobs, hosted apps |
| Team collaboration | Shared workspace inside Claude Team | Shared sessions, files, apps, and workspace roles around one AI coworker |
| Build apps | No, runs prebuilt workflows | Yes, agents build and host full web apps on your workspace |
| Pricing model | Bundled into Claude Team or Enterprise seat pricing | Monthly plans with included credits and paid-reserve overage |
| Best for | Owners who live inside packaged SaaS and want AI inside it | Teams that want one AI coworker across tools, plus the ability to build and run stuff |
## When Claude for Small Business Wins
Be honest about this. If your business is 100% inside QuickBooks, HubSpot, Google Workspace, and a couple of other packaged SaaS tools, and the work you want AI to do already maps to one of Anthropic's 15 workflows, Claude for Small Business is the right shape. You do not need a cloud server. You do not need custom apps. You need AI inside the tools you already pay for, with approval gates so nothing reckless happens.
Specifically, it wins when:
- The workflow is already named (invoice chasing, bookkeeping prep, lead follow-up).
- Your team already has Claude Team or Enterprise seats.
- You want first-party connectors with Anthropic on the hook for support.
- Non-technical owners need a packaged answer, not a workspace to configure.
That is a real audience. It is not the audience Duet is built for.
## When Duet Wins
Duet wins when your work does not fit cleanly inside a packaged SaaS list, or when you want one teammate that spans every tool instead of fifteen Claude buttons in fifteen different apps.
It wins when:
- You want a named AI coworker, not a feature inside another product.
- Your workflows mix tools, code, files, and scheduled work.
- You want to assign work, watch it run, inspect artifacts, and approve external actions in one place.
- You want the agent to build a custom dashboard, scraper, or internal tool and then keep running it. See [how to build an internal tool in a day](/blog/how-to-build-internal-tool-in-a-day-with-ai).
- You want memory and durable work history that spans weeks, not isolated prompts.
- You want to use Claude as the underlying model when you want to, and switch to GPT or Gemini when that fits better.
- You want a 24/7 agent that wakes up on cron and does its job. See the [24/7 agent setup guide](/blog/how-to-set-up-a-24-7-ai-agent).
This is the build-and-run lane. Claude for Small Business is a build-not-required, packaged-runtime product. Duet is the workspace where you assemble and operate your own.
## Pricing
Claude for Small Business is bundled into Claude Team and Enterprise. At launch, Team seats sit in the same range as Claude Pro per user per month, with Enterprise quoted per deal. The connectors and 15 workflows are included.
Duet offers Starter, Pro, and Max monthly plans with included credits. A workspace owner designates a payer who manages payment methods, reserve topups, limits, and billing history under user settings. The [pricing page](/pricing) has the current plans.
For a 10-person business, two rough comparisons:
- Claude Team at roughly $25 per seat per month, 10 seats, is about $3,000 per year, plus any Enterprise add-on for higher connector usage.
- Duet offers Starter, Pro, and Max monthly plans; compare included credits and paid-reserve overage with your expected automation and app-hosting workload.
The pricing question is not "which is cheaper" in the abstract. It is: do you want to pay per seat for AI inside other tools, or choose a shared-credit monthly plan for a workspace you own?
## Can Duet Use Claude as the Model
Yes. Duet is multi-model. You can run any agent session on Claude Opus 4.7, Claude Sonnet, GPT-5.5, Gemini, or xAI, and switch per task. If you love Claude's reasoning but you want Duet's workspace shape, you get both. This is the most honest way to frame the choice: Claude for Small Business is a packaged product on top of Claude. Duet is a workspace that can run on top of Claude, and several other models, with persistence and apps the packaged product does not offer.
## How to Try Duet
Five minutes, no setup tax:
1. Sign up at [duet.so](/).
2. Connect the tools you use through managed integrations. Slack, Notion, Linear, Gmail, HubSpot, QuickBooks, and the long tail are all supported.
3. Give your AI coworker its first job. Try one of the workflows from our [SMB guides](/blog), like bookkeeping automation or competitive monitoring.
4. Set the job on a recurring schedule if it should run every day or every week.
5. Watch the run, inspect the files it produced, and approve any outbound action.
You can have a running AI coworker in the time it takes to read this paragraph twice.
## Frequently Asked Questions
### Is Claude for Small Business better than Duet?
Neither is universally better. Claude for Small Business is better if your business runs entirely inside packaged SaaS tools like QuickBooks and HubSpot, and you want AI inside those tools with prebuilt workflows. Duet is better if you want one AI teammate that spans every tool, builds custom apps, and runs scheduled work, with multi-model routing across Claude, GPT, Gemini, and xAI.
### What is Claude for Small Business?
Claude for Small Business is Anthropic's packaged AI product for SMB owners, [launched on May 13, 2026](https://www.anthropic.com/news/claude-for-small-business). It includes direct connectors to QuickBooks, PayPal, HubSpot, Canva, Docusign, Google Workspace, and Microsoft 365, plus 15 prebuilt workflows and 15 prebuilt skills with human approval gates on outbound actions.
### Does Duet work with QuickBooks and HubSpot?
Yes. Duet connects to QuickBooks, HubSpot, and hundreds of other tools through managed integrations. The difference vs Claude for Small Business is that Duet treats these as tools the agent uses, not as first-class workflow surfaces. Your AI coworker can pull data from QuickBooks, summarize it in a Notion doc, post the summary to Slack, and schedule the whole job to run every Monday.
### Can I run Claude Code or Codex inside Duet?
Yes. Duet's cloud workspace can run [Claude Code](/blog/how-to-run-claude-code-in-the-cloud), Codex, and other coding agents on your private server. That makes Duet a popular workspace for developers who want Claude Code persistent and team-accessible rather than tied to one laptop.
### Which is cheaper for a 10-person team?
It depends on headcount and workload. Claude Team is priced per seat, while Duet's monthly plans include shared credits and use the designated payer's reserve for overage. Teams that mostly want AI inside existing SaaS may still find Claude for Small Business simpler to budget.
### Can Claude for Small Business build a custom app for me?
No. Claude for Small Business runs prebuilt workflows inside connected SaaS tools. It does not host custom apps or write code that you then deploy. Duet does. The agent can build a custom dashboard or internal tool, host it on your workspace, attach a [custom domain](/blog/custom-domain-names-in-duet), and keep running it.
### Which is better for non-technical owners?
If you want a packaged answer that lives inside the SaaS you already use, Claude for Small Business is friendlier on day one. If you want a named AI coworker you can hire, give jobs to, and grow into a real teammate, Duet is friendlier across the first month. Onboarding in Duet now starts with naming your AI and giving it an identity card, which is the framing most non-technical owners respond to.
### Can I use both?
Yes. Many teams will. Keep Claude for Small Business inside your QuickBooks and HubSpot for the narrow, packaged jobs it does well. Use Duet as your team's general-purpose AI workspace for everything else: cross-tool workflows, custom apps, scheduled jobs, and the work that does not fit a prebuilt list.
---
Source: https://duet.so/blog/duet-vs-open-claw-vs-hermes
# Open Claw vs Hermes vs Duet: Which AI Agent Is Actually Right for You?
*Open Claw is a developer tool. Hermes is agent infrastructure. Duet is a cloud workspace that runs business workflows without any installation. Here's the honest comparison.*
By Duet Team. Published 2026-06-09, updated 2026-06-09. 12 min read.
Open Claw, Hermes, and Duet are all AI agents — but they solve different problems for different people. Open Claw is a personal developer companion. Hermes is infrastructure for running autonomous agent fleets. Duet is a cloud workspace that runs business workflows without installation. If you're not a developer, that distinction changes everything.
---
## What Is Open Claw (And What Just Happened With OpenAI)?
Open Claw is an open-source, MIT-licensed AI agent you install on your own machine. It runs a local "Gateway" process that manages an AI agent, persists memory, handles scheduling, and connects to messaging platforms like Telegram, Discord, and Slack. You supply your own API keys — there's no Open Claw subscription fee.
The install is a single terminal command: `curl -fsSL https://openclaw.ai/install.sh | bash`. From there, you configure a JSON5 file, set up your model provider API key, and optionally connect messaging bots. See the [OpenClaw official setup guide](https://docs.openclaw.ai/start/getting-started) for the full step-by-step.
Open Claw was built by Peter Steinberger (@steipete), a well-known iOS developer. On February 14, 2026, Steinberger published [his announcement post](https://steipete.me/posts/2026/openclaw): he was joining OpenAI to work on bringing agents to everyone. OpenAI now **sponsors** Open Claw — it does not own or acquire it. The project is moving to a foundation structure and stays MIT open source. Steinberger's own words: "OpenClaw will move to a foundation and stay open and independent."
This news drove the current search surge around "open claw alternative." Developers want to know if it's still worth using. The short answer: yes, nothing changed about the software itself.
For a deeper head-to-head, see [our dedicated Duet vs OpenClaw comparison](/guides/duet-vs-openclaw).
---
## What Is Hermes Agent? (Nous Research)
Hermes is an open-source agent built by [Nous Research](https://hermes-agent.nousresearch.com) — the AI lab behind the Hermes, Nomos, and Psyche model families. The official tagline is **"The Agent That Grows With You."** The official description: "An autonomous agent that lives on your server, remembers what it learns, and gets more capable the longer it runs."
Where Open Claw is a personal companion, Hermes is developer infrastructure. It supports 6 terminal backends — local, Docker, SSH, Daytona, Singularity, and Modal. It acts as both an MCP client (consuming external tool servers) and, increasingly, as an MCP server itself, so other agents can call its tools. For a plain-language breakdown of [what MCP actually is](/guides/agent-skills-101-tools-vs-mcp-vs-skills) versus skills or plugins, that guide covers it clearly.
Community framing from r/openclaw describes Hermes as "somewhere between Open Claw and a coding agent — half AI assistant, half agent infrastructure." That tracks: features like batch processing, trajectory export, RL training data, and "Programmatic Tool Calling" (collapsing multi-step pipelines into single inference calls) are built for researchers and engineers, not business operators.
The YAML-based config, 6-backend sandbox system, and Nous Portal OAuth shortcut (`hermes setup --portal`) make for a cleaner install than Open Claw — but the target user is the same: someone comfortable in a terminal.
---
## The Setup Problem: Why Non-Developers Bounce
Both tools require a terminal. That's not a criticism — it's accurate product positioning.
For Open Claw, [the official setup documentation](https://docs.openclaw.ai/start/getting-started) shows the steps: install Node.js v22.19+ (v24 recommended), run the curl install, go through the onboarding wizard, set your API key, and configure the Gateway on port 18789. A comfortable developer gets through the basics in roughly 15–30 minutes.
Production hardening is a different story. Binding to localhost, enabling sandbox mode, configuring tool deny lists, and setting up systemd isolation are an ongoing security commitment — community guides document the hardening process as a [multi-hour undertaking](https://aimaker.substack.com/p/openclaw-security-hardening-guide), with monthly maintenance recommended for any production use.
Hermes has a cleaner installer (auto-handles Python, Node.js, ripgrep, ffmpeg), but similar depth: YAML config, 6 sandbox backends, per-platform bot tokens for each messaging channel (Telegram requires BotFather, Discord requires an application and OAuth), and server administration knowledge if you want it running when your laptop is off.
The honest sentence: neither tool was designed for someone who doesn't know what a terminal is. That's fine — they're developer tools, and they're excellent at what they do. But it means non-technical users have nowhere to go with them.
---
## Cloud AI Workspace Alternatives: Built for Business, Not Terminals
The gap that Open Claw and Hermes leave is the "cloud AI workspace" category — no install, runs 24/7 on a persistent cloud server, and designed around business workflows rather than developer tasks. Two products compete here.
**Simular's Sai** is the closest cloud competitor. Sai runs on a cloud-based virtual desktop (macOS or Windows VM) and operates it the way a human would — clicking, typing, running GUI applications. It ranked #1 on the OSWorld computer-use benchmark with a 72.6% success rate. Pricing from [Sai's pricing page](https://simular.ai/pricing): $20/month (Plus, single user, personal projects) or $500/month (Pro, team workflow sharing, private VM). Sai was invite-only at time of writing — worth checking whether that's changed.
Sai is a strong pick for individual desktop automation. What it doesn't offer: team channels, persistent business memory, scheduling/cron at the system level, or a community skills ecosystem. It completes tasks you trigger on a virtual desktop — it doesn't run your business operations end-to-end. For a full breakdown of [self-hosted OpenClaw for teams](/blog/openclaw-vs-managed-ai-agent-platforms) versus managed alternatives, that post goes deeper.
**Duet** takes a different approach entirely: no download, no terminal, no API keys to manage. Your business workflows run on a persistent cloud server. Everything is accessible from a browser.
---
## What Does an AI Employee Actually Look Like for a Business?
Here's what it looks like in practice. Every morning, Duet has already worked through your inbox — emails are categorized, routine questions have draft replies waiting for your approval, and anything that needs your attention is flagged. Your laptop was closed. You were asleep. It didn't matter.
That's possible because Duet runs on a persistent cloud server, not your machine. And it means you can chain that email review into a workflow: if a client emails asking for a proposal, Duet can pull the relevant context from your CRM, draft the proposal, and drop a Slack message for your team — all without a prompt from you.
This is the "AI employee" framing. Not a tool you use, but a teammate that runs. Duet combines reusable instructions in Files, durable business context in Train, managed Integrations, team Sessions, and scheduling so workflows such as email triage, lead enrichment, SEO audits, content writing, and product analytics can run repeatedly.
The "always-on" piece matters. Open Claw and Hermes stop when your machine does, unless you self-manage a VPS. Duet's server never closes. For a step-by-step on what that looks like, see [how to set up a 24/7 AI agent](/blog/how-to-set-up-a-24-7-ai-agent).
**[Start with a 7-day free trial. No credit card required.](/)**
---
## Open Claw vs Hermes vs Duet: Full Comparison
| | **Open Claw** | **Hermes** | **Duet** | **Sai (Simular)** |
| --------------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------ | ------------------------------------------------------ | -------------------------------------------------------------- |
| **Setup** | Terminal, Node.js v22.19+; ~15–30 min basic; 2–3+ hrs for production hardening | Terminal, curl install; cleaner deps; similar hardening commitment | Zero install — browser only; ~10 min to first workflow | Invite-only signup; app download; no API keys |
| **Runs when laptop is off** | ❌ Local machine only | ❌ Local/self-managed server | ✅ Persistent cloud server, 24/7 | ✅ Cloud VM, but task-triggered |
| **Non-technical users** | ❌ Developer-only | ❌ Developer-only | ✅ Designed for business operators | ⚠️ Low setup; task-level use only |
| **Team collaboration** | ❌ Single user | ❌ Single user | ✅ Shared sessions and workspace roles | ❌ Single user on Plus; workflow sharing on Pro ($500/mo) only |
| **Pricing** | Free (you pay API costs) | Free (you pay API costs) | 7-day trial; monthly Starter, Pro, and Max plans | Plus $20/mo; Pro $500/mo |
| **MCP / integrations** | ✅ MCP tools, sub-agents | ✅ MCP client + server, 6 backends | ✅ Managed integrations and API-first tools | ⚠️ GUI automation; no MCP ecosystem |
| **Always-on workflows** | ❌ Requires self-hosted VPS | ❌ Requires self-hosted VPS | ✅ Scheduled work on a persistent server | ⚠️ Task-level; not persistent business systems |
| **Best for** | Developers: local personal agent, full data control | Developers: multi-agent infrastructure, research workflows | Business operators: managed AI workspace, no infra | Individuals: cloud desktop task automation |
The open claw vs hermes question comes down to scope. Open Claw is a personal companion — it grows with you and optimizes for a single user's productivity. Hermes is infrastructure — it optimizes for running and orchestrating agent systems. Both are excellent for their audience. Neither was designed for someone running a small business without engineering support.
---
## Which Should You Choose?
**Choose Open Claw if:** You're a developer who wants a local, personal agent with full control over your data and environment. MIT license, zero subscription, runs exactly where you want it. The OpenAI sponsorship changes nothing about the software — it's still yours to self-host.
**Choose Hermes if:** You're a developer building or running multi-agent systems, need infrastructure-grade tooling with 6 sandbox backends and first-class MCP support, and are comfortable with a deeper setup investment. Strong pick for AI researchers and engineers.
**Choose Duet if:** You're running a business — not writing code — and need workflows to run without maintaining servers: email triage, lead enrichment, content pipelines, durable team sessions, and scheduling.
**Choose Sai if:** You primarily need cloud-based computer-use task automation — clicking through software, navigating web workflows on a virtual desktop. Worth evaluating for individual use; expect individual-task scope, not persistent business operations.
For more options in this space, see [6 best AI agent builders in 2026](/blog/6-best-ai-agent-builders-in-2026).
---
## Frequently Asked Questions
### Can I use an AI agent without installing anything or writing code?
Yes. Cloud-native AI agents like Duet run entirely in the browser — no terminal, no API key configuration, no server setup. You sign up, connect your email or other tools, and start delegating workflows immediately. Open Claw and Hermes both require local terminal installation and developer prerequisites. Simular's Sai requires an invite and app download, but no coding. If you don't want to touch a command line, you need a cloud-native option.
### What is the best no-code alternative to Open Claw for small business owners?
For small business owners who need AI workflows without coding, Duet is the most complete option. It runs on a persistent cloud server — no installation, no terminal — and handles tasks like email triage, content scheduling, and lead enrichment 24/7. The free trial lasts 7 days with no credit card required. Simular's Sai is an alternative for desktop task automation, but it's single-user and geared toward individual computer-use tasks rather than ongoing business operations.
### What is the difference between Open Claw and Hermes Agent?
Open Claw is a personal AI companion designed to grow with a single developer — it runs locally, handles your files and terminal, and is optimized for personal productivity. Hermes (built by Nous Research, tagline: "The Agent That Grows With You") is closer to agent infrastructure: it supports 6 terminal backends, acts as both an MCP client and server, and is better suited to developers building or running multi-agent systems. Both require terminal installation and ongoing developer maintenance.
### Does Duet replace Open Claw, or is it a different product?
Duet is a different product category, not a drop-in replacement for Open Claw. Open Claw is a self-hosted, local developer agent — you control the server, you manage updates, you own the terminal. Duet is a managed cloud workspace for business workflows. It doesn't run Open Claw under the hood; it's built from scratch for non-technical operators who need persistent AI without infrastructure overhead. See our [Duet vs OpenClaw guide](/guides/duet-vs-openclaw) for a full comparison.
### What happened to Open Claw after Peter Steinberger joined OpenAI?
On February 14, 2026, Open Claw creator Peter Steinberger [announced](https://steipete.me/posts/2026/openclaw) he was joining OpenAI. OpenAI **sponsors** Open Claw — it does not own or acquire it. The project is moving to a foundation structure and remains MIT open source. Steinberger's words: "OpenClaw will move to a foundation and stay open and independent." The underlying software, self-hosted model, and setup complexity are all unchanged.
### Is there an AI agent that keeps working when my laptop is closed?
Yes — cloud-native agents like Duet run on persistent cloud servers 24/7, regardless of whether your device is on. Open Claw and Hermes run on your local machine (or a server you self-manage), so they stop when your machine does unless you configure a VPS. Simular's Sai uses a cloud VM but is task-triggered. For always-on business workflows — email monitoring, scheduled reports, recurring automations — see our guide on [setting up a 24/7 AI agent](/blog/how-to-set-up-a-24-7-ai-agent).
### What is the difference between a no-code AI agent and a developer AI agent?
A developer AI agent (like Open Claw or Hermes) is installed via command line, configured through code or YAML files, and requires you to manage updates, security hardening, and server infrastructure. A no-code AI agent (like Duet) runs in a browser, connects to your tools via OAuth, and is fully managed. Developer agents offer maximum flexibility and control. No-code agents offer faster setup and lower ongoing maintenance — designed for business operators, not engineers. See our [roundup of AI agent builders in 2026](/blog/6-best-ai-agent-builders-in-2026) for more options.
---
Source: https://duet.so/blog/duet-vs-openai-workspace-agents-vs-claude-for-small-business-vs-viktor
# Duet vs OpenAI Workspace Agents vs Claude for Small Business vs Viktor (2026 Guide)
*Duet, OpenAI Workspace Agents, Claude for Small Business, and Viktor compared on persistence, team fit, build+run, integrations, pricing, and SMB fit.*
By Duet Team. Published 2026-05-21, updated 2026-07-19. 23 min read.
In 2026, four very different products are competing for the same SMB and small-team AI lane: [Duet](/), OpenAI Workspace Agents, [Anthropic's Claude for Small Business](https://www.anthropic.com/news/claude-for-small-business), and Viktor.
They all promise an "AI coworker," but the shape underneath each one is different.
This guide compares them on the dimensions that actually decide which one to pick.
## TL;DR
| Product | What it is | Shape | Best for |
| ----------------------------- | ------------------------------------------------------------------------------------------- | -------------------------------------------------- | ---------------------------------------------------------------------- |
| **Duet** | Cloud agent workspace: private server, persistent AI teammate, sessions, files, apps | Standalone workspace, team-native, build + run | Small teams that want one named AI coworker across every tool |
| **OpenAI Workspace Agents** | Agents launched as part of OpenAI's workspace surface for business users | Agents inside the OpenAI product surface | Teams already standardized on ChatGPT Business / Enterprise |
| **Claude for Small Business** | Anthropic's packaged SMB AI: 15 prebuilt workflows + 15 skills with human approval | AI as a toggle inside connected SaaS (QB, HubSpot) | Owners whose work already lives inside packaged SaaS |
| **Viktor** | "Autonomous AI coworker" that lives inside Slack / Microsoft Teams with 3,000+ integrations | Per-seat SaaS agent layered on top of a messenger | Teams whose work happens in Slack/Teams and want a plug-in AI teammate |
**Questions this page answers**
- What is the difference between Duet, OpenAI Workspace Agents, Claude for Small Business, and Viktor?
- Which AI coworker is best for a small business in 2026?
- Does Duet integrate with Slack like Viktor does?
- Is Claude for Small Business better than OpenAI Workspace Agents?
- Which of these can actually build and host a custom app?
- Which is the cheapest for a 5–15 person team?
## What is Duet?
[Duet](/) is a cloud agent workspace. Every user and team gets a private cloud server with a persistent, always-on AI teammate. Work is organized into durable sessions whose events show assignments, progress, questions, and results. The product combines that agent and server with memory, files, scheduling, integrations, and app hosting.
The core wedge is **Build and Run**. Lovable builds you an app and leaves. Duet builds you an app and runs it. The AI coworker shows up tomorrow with full memory of yesterday, the files it created, the integrations you connected, and the scheduled jobs you set up.
Every Duet workspace gets a dedicated cloud VM, persistent Files, durable facts and sources in Train, managed Integrations, hosted Apps, durable Sessions, and multi-model routing.
## What are OpenAI Workspace Agents?
OpenAI Workspace Agents are OpenAI's shared-agent feature inside ChatGPT — see the April 2026 update below for what changed, who's eligible, and what it costs now.
In practice, Workspace Agents are an extension of OpenAI's existing surface: shared workspaces, admin controls, and OpenAI-owned connectors. They are appearing in category searches alongside Duet, Claude for Small Business, and Viktor as a "business AI agent" option, which is why they belong in this comparison even though they are not pitched as an SMB-specific product the way Anthropic's launch is.
In practice, Workspace Agents can browse websites, run code for data analysis, generate slides and spreadsheets, and connect to dozens of tools, including Slack, Gmail, Google Calendar, SharePoint, Drive, Salesforce, Notion, and Atlassian.
Agents can run on a cron-style schedule, pause for human approval, and resume, making them capable of multi-step workflows that span hours. Custom integrations beyond the built-in connectors can be wired through the Model Context Protocol (MCP). The shape is broad and horizontal: if ChatGPT can do it, a Workspace Agent can do it on a schedule.
## OpenAI Workspace Agents: What Changed for Teams Since the April 2026 Launch?
> OpenAI Workspace Agents are Codex-powered shared agents inside ChatGPT Business, Enterprise, Edu, and Teachers — not Plus or Pro. Launched April 22, 2026 and generally available May 21–22, they run scheduled cloud workflows with files, tools, memory, and Slack. Since July 6, 2026, runs use token-based credits; a typical GPT-5.5 run costs about 5–25 credits.
### Who can use OpenAI Workspace Agents now?
You need a ChatGPT Business, Enterprise, Edu, or Teachers plan. Personal Plus ($20/mo) and Pro ($100/mo) don't include workspace agents at all.
OpenAI's [launch announcement](https://openai.com/index/introducing-workspace-agents-in-chatgpt/) lists all four eligible plans. Its dated [release notes](https://help.openai.com/en/articles/11391654-chatgpt-business-release-notes) name Business, Enterprise, and Edu specifically in the generally-available entry — treat Teachers as listed-but-not-explicitly-GA-confirmed, not dropped and not promoted.
Enterprise workspaces ship agents off by default; an admin has to turn them on. Business workspaces ship them on by default. Weighing OpenAI's surface against a [Codex-based build](/guides/duet-vs-codex)? Eligibility is the first filter.
### What do OpenAI Workspace Agents cost now that the free period has ended?
Free access ended July 6, 2026, per OpenAI's [release notes](https://help.openai.com/en/articles/11391654-chatgpt-business-release-notes). Runs now bill on a published token-credit rate card, on top of the ChatGPT Business seat price.
ChatGPT Business is $25/user/mo billed monthly, or $20/user/mo billed annually (2-user minimum) — [OpenAI's business plan page](https://chatgpt.com/business/business-plan/) confirms both rates. That seat buys the workspace; agent runs draw separately from a shared pool of Codex credits.
| Model | Input (per 1M tokens) | Cached input (per 1M) | Output (per 1M) |
| ------- | --------------------- | --------------------- | --------------- |
| GPT-5.5 | 125 credits | 12.50 credits | 750 credits |
| GPT-5.4 | 62.50 credits | 6.25 credits | 375 credits |
_OpenAI's own worked example: 20k input + 80k cached input + 5k output tokens ≈ 7.25 credits. A typical end-to-end GPT-5.5 run costs about 5–25 credits, per [OpenAI's rate card](https://help.openai.com/en/articles/11481834-chatgpt-rate-card)._
Someone still has to watch that meter — [who runs your agent after you build it](/blog/who-runs-your-ai-agent-after-you-build-it) matters more once runs bill by the token instead of the seat.
### Is memory actually shared across the team?
No. OpenAI's own documentation says an agent's memory is not shared across different end users — only the agent's definition is.
The [cookbook](https://developers.openai.com/cookbook/articles/chatgpt-agents-sales-meeting-prep) is explicit: memory "is not shared across different end users of our agent." The [Security Overview](https://cdn.openai.com/business-guides-and-resources/workspace-agents-security-overview.pdf) adds the Slack half — memory is scoped per-user for ChatGPT runs and per-deployed-channel for Slack runs, and the two pools are never cross-referenced.
| Object | Shared across the team? | Source |
| ---------------------------------------------------- | ----------------------------------------------------------------------------------- | --------------------------- |
| Agent definition (instructions, tools, connectors) | Yes — reusable per workspace group membership | OpenAI Help Center |
| Connected files/folders | Yes, if the agent's connections are shared | Cookbook + Help Center |
| Per-user memory (notes, drafts, learned preferences) | **No** — scoped to the individual end user | Cookbook; Security Overview |
| Slack-channel memory | Separate pool — not cross-referenced with ChatGPT memory | Security Overview |
| Durable project/run history a teammate can pick up | Partial — logged to the Compliance Platform (Enterprise/Edu); no shared "run inbox" | Security Overview |
Everyone on the team can run the same agent. Nobody inherits a teammate's notes.
### OpenAI Workspace Agents vs Claude Cowork vs an owned agent workspace — which fits your team?
Workspace Agents is the managed option living inside ChatGPT. Claude Cowork — a separate, personal/local Anthropic product from the Claude for Small Business profile above — skews individual and local-file. An owned, persistent workspace keeps files, memory, schedules, and outputs as the operating layer regardless of model.
| Dimension | OpenAI Workspace Agents | Claude Cowork | Owned shared agent workspace |
| ----------------------- | --------------------------------------------------------------- | ---------------------------------------- | --------------------------------------------------------------------------------------- |
| Execution surface | Cloud, inside ChatGPT | Desktop / local files | Persistent private cloud server |
| Team sharing | Agent definition shared by workspace group | Personal, single-user routines | Team-native by default |
| Memory scope | Per-user (ChatGPT); per-channel (Slack); never cross-user | Local to that one user | Persistent, team-owned workspace memory |
| Durable state | Partial — Compliance logs (Enterprise/Edu); no shared run inbox | Local files on that user's machine | Files, cron, and run artifacts persist on the team's own server |
| Ownership / portability | Data lives inside OpenAI's product surface | Data lives on the user's device | Workspace and files stay the team's own |
| Pricing model | Business seat $25/user/mo + token credits | Rides on a paid Claude tier | Monthly plan with included credits and a paid reserve for overage |
| Best fit | Teams already standardized on ChatGPT/Slack | One strong individual, local-file worker | Teams that need files, memory, schedules, and outputs to persist as one operating layer |
Pick the shape that matches how the work actually lives, not just which model is smartest:
- Pick Workspace Agents if the team already standardizes on ChatGPT and wants governed shared agents inside ChatGPT and Slack.
- Pick Claude Cowork for a strong personal, local-file worker.
- Pick a durable, owned agent workspace when the business needs persistent files, memory, schedules, run artifacts, and hosted outputs to remain the operating layer across whichever agents or models it uses.
None of this is really a question of which agent is smartest — it's a question of where the work lives once the demo ends. OpenAI's workspace agents are a genuinely capable feature _inside_ ChatGPT's surface: governed, team-shareable, and — as of this update — priced and dated clearly for the first time.
But they're still a feature of one chat product, scoped to that product's plans and that product's memory model.
Duet takes the other shape: a shared, persistent cloud workspace — an agent drive — that isn't defined by any single vendor's assistant surface. Sessions, files, memory, schedules, and the apps your agent builds all live in one place your team keeps, independent of which model happens to run a given task.
It's the **Build + Run** idea: an agent that builds the tool your business needs and keeps running it, not just a chat window you visit.
If your team runs client-adjacent or recurring work and wants to compare that shape directly, [see how agencies use a shared agent workspace](/use-cases/agencies).
### What should you test after the demo?
A scheduled run proving the agent works unattended is a different claim from an inspectable, continuable workspace. Test what happens next, not just whether the demo ran.
1. Where do a run's artifacts actually land, and can a teammate find them without asking whoever built the agent?
2. Who can see run history and failures — is that an admin/compliance surface only, or something the whole team can check?
3. What happens to in-flight work if the teammate who owns the agent's connections leaves?
4. Does a month of scheduled runs have a spend ceiling you can set per agent? Workspace-level spend controls exist today; OpenAI's own [Security Overview](https://cdn.openai.com/business-guides-and-resources/workspace-agents-security-overview.pdf) lists per-agent budget caps as "coming soon," not shipped.
5. If you trigger an agent by API, can your system retrieve the result? Today that call returns `202 Accepted` with no run ID — response retrieval is also "coming soon."
That's the real test, and it's the same test whichever platform you're evaluating. [AI agent workspace vs. control plane](/blog/ai-agent-workspace-vs-control-surfaces) walks through it dimension by dimension.
## What is Claude for Small Business?
[Claude for Small Business](https://www.anthropic.com/news/claude-for-small-business) is Anthropic's packaged AI product for SMB owners, launched on **May 13, 2026**. It includes direct connectors into QuickBooks, PayPal, HubSpot, Canva, Docusign, Google Workspace, and Microsoft 365, plus **15 prebuilt workflows** and **15 prebuilt skills**, with **human approval required** on outbound actions.
The framing is sharp: AI as a toggle inside the SaaS you already pay for. You open QuickBooks, you click a Claude button, the workflow runs. Pricing rides on top of any paid Claude tier, starting at Pro ($20/month). The target user is the non-technical owner who wants a packaged answer, not a workspace to configure.
## What is Viktor?
Viktor is an "autonomous AI coworker with its own persistent cloud computer," launched publicly in February 2026. It lives inside Slack and Microsoft Teams, advertises 3,000+ integrations, and starts at $50/workspace/month (with 20,000 credits included) layered on top of the messenger your team already uses.
Positioning-wise, Viktor is the closest direct competitor to Duet on the "AI coworker" framing. The key structural difference is dependency: Viktor is a guest inside Slack or Teams. If your team does not live in those messengers, Viktor does not have a home; if it does, Viktor is one slash command away from being part of a thread.
## Side by Side
| Dimension | Duet | OpenAI Workspace Agents | Claude for Small Business | Viktor |
| ---------------- | -------------------------------------------------------------------- | ------------------------------------------------------- | ---------------------------------------------------------------- | ----------------------------------------------------------- |
| **Persistence** | Private cloud server, persistent files, cron, memory, hosted apps | Account / workspace context inside ChatGPT | Account-level memory, per-conversation context | Cloud compute attached to the per-workspace agent |
| **Team-native** | Shared sessions, files, apps, and roles around one AI coworker | Team workspace inside ChatGPT Business / Enterprise | Shared workspace inside Claude Team / Enterprise | Lives inside Slack / Teams as a participant |
| **Build + Run** | Build and run: agent builds custom apps and keeps running them | Agent actions, no first-class custom-app hosting layer | Run-only: executes prebuilt workflows, no custom apps | Run-focused: per-workspace agent, no custom-app hosting |
| **Integrations** | Open connector layer through managed connectors, plus custom code | OpenAI-owned connectors, growing plugin / app ecosystem | First-party connectors: QuickBooks, PayPal, HubSpot, Canva, etc. | 3,000+ integrations via Slack / Teams ecosystem |
| **Deployment** | Standalone workspace at duet.so, web + mobile + desktop | Inside ChatGPT (web, desktop, mobile) | Inside Claude product surface | Plugin inside Slack / Microsoft Teams |
| **Pricing** | Monthly plans with included credits and paid-reserve overage | ChatGPT Business $25/seat + credits | Any paid Claude tier (Pro $20/mo+) | $50/workspace/mo + credits |
| **Identity** | Named AI coworker with an ID card you "hire" | "ChatGPT" branded agent inside your workspace | AI as a toggle inside existing SaaS | Single named persona ("Viktor") added as a Slack/Teams user |
| **SMB fit** | Strong for teams that want one workspace across every tool plus apps | Strong for teams already paying for ChatGPT Business | Strong for owners who already live inside QuickBooks / HubSpot | Strong for Slack- or Teams-first teams |
## The Core Philosophy Difference
The cleanest way to think about this market is to ask, "what does the AI sit on top of?"
- **OpenAI Workspace Agents** sit on top of OpenAI. The agent lives where ChatGPT already lives.
- **Claude for Small Business** sits on top of your existing SaaS. The agent is a toggle inside QuickBooks, HubSpot, and Google Workspace.
- **Viktor** sits on top of your messenger. The agent is a user inside Slack or Microsoft Teams.
- **Duet** sits on top of its own cloud workspace. The agent is a named coworker with an ID card, a private server, memory, files, cron, and the ability to build and host apps.
All four shapes are valid, but they bias different teams. If your work is already inside ChatGPT, Workspace Agents make sense. If your work is already inside QuickBooks and HubSpot, Claude for Small Business makes sense. If your work happens in Slack, Viktor makes sense. If you want one AI teammate to span every tool and build its own apps and run scheduled work, Duet makes sense.
## When Each One Wins
### OpenAI Workspace Agents
When you are already standardized on ChatGPT Business or Enterprise, your team prefers a single OpenAI surface for everything, and you don't need a custom workspace or hosted apps. It is the lowest-friction option for teams that are already inside the OpenAI ecosystem.
### Claude for Small Business
When your business runs almost entirely inside packaged SaaS like QuickBooks, HubSpot, Google Workspace, and Microsoft 365, the work you want AI to do maps to one of Anthropic's 15 workflows, and you want first-party connectors with Anthropic on the hook for support. Non-technical owners who want a packaged answer rather than a workspace to configure will be most comfortable here.
### Viktor
When your team genuinely lives inside Slack or Microsoft Teams, you don't want to introduce a new product surface, and you are happy paying $50/workspace/month for an AI participant. The 3,000+ integration count is real depth, and being inside the messenger is the lowest-friction onboarding shape for a Slack-first team.
### Duet
When you want one named AI coworker, not a feature inside another product, and your work mixes tools, code, files, and scheduled jobs. Duet wins specifically when you want to build and run: have the agent build a custom dashboard, scraper, or internal tool and then keep running it on a private server with a custom domain. The monthly subscription and paid reserve belong to the owner designated by the workspace, rather than attaching a separate subscription to each member.
## Use Cases of OpenAI, Claude, Viktor, Duet
Here is what each platform looks like in practice for a 5-to-15-person team.
### OpenAI Workspace Agents
A 10-person sales team uses a Workspace Agent to prep for every customer call. The agent pulls the prospect's latest activity from Salesforce, checks their calendar for scheduling conflicts in Google Calendar, summarizes recent email threads from Gmail, and drops a one-page brief in Slack 30 minutes before the meeting. It runs on a schedule every morning and flags any prospects that went silent for more than a week.
### Claude for Small Business
A solo accounting firm owner connects Claude to QuickBooks and Gmail. Every Monday, Claude scans the week's incoming invoices, matches them against open purchase orders, flags discrepancies, and drafts follow-up emails to vendors with mismatched amounts. The owner reviews and approves each email before it sends. No code, no configuration beyond connecting the accounts.
### Viktor
A 7-person marketing agency runs Viktor inside Slack. Every morning at 8am, Viktor pulls spend and ROAS data from Google Ads and Meta Ads for each client, compares it against targets, and posts a summary in the team's #client-reports channel. When spend exceeds the daily budget by more than 15%, Viktor flags it immediately. The team discusses it in-thread and Viktor adjusts the report cadence based on feedback.
### Duet
A 5-person e-commerce startup asks Duet to build a live inventory dashboard. Duet writes a Next.js app, connects it to the team's Shopify and warehouse API, hosts it on a custom domain (inventory.theirstore.com), and sets up a cron job to refresh the data every hour. When stock for any SKU drops below 50 units, Duet records an alert in the durable session and can deliver it through a connected service. The dashboard, cron job, and alert system all persist.
## Persistence and the "Run" Half
Persistence is the single dimension that separates this market the most.
- **Workspace Agents** persist context inside an OpenAI workspace, but custom-app hosting and arbitrary background jobs are not the product shape.
- **Claude for Small Business** persists account-level memory and conversation context, but the workflows are the unit of work, not a server you own.
- **Viktor** ships per-workspace cloud compute, but that compute exists to power the agent, not to host customer apps with custom domains.
- **Duet** persists everything that lets you actually run: a private server, Files, trained workspace context, Integrations, scheduled work, Sessions, and hosted Apps. That is the wedge.
If your AI use case ends at "answer a question" or "execute a packaged workflow," any of the four is fine. If it extends to "build me a dashboard, host it, and update it every Monday at 9am," Duet is the shape that includes the run half.
## Where Each One Falls Short
No comparison is useful if it only says nice things. Here is what each product genuinely cannot do or does not do well yet.
### OpenAI Workspace Agents
- Still in research preview. Features and pricing are not final, and enterprise teams may hit rough edges.
- No private server or custom-domain app hosting. Agents execute tasks but do not give you a persistent environment you own.
- Connector ecosystem (60+) is growing but younger than Viktor's 3,000+ integrations.
### Claude for Small Business
- Locked to 15 prebuilt workflows and 15 skills at launch. If your use case does not map to one of them, you wait for Anthropic to add it.
- No custom app building or hosting. Claude runs workflows inside your existing SaaS; it does not build new tools for you.
- Per-seat pricing scales with headcount. A 15-person team pays 15x even if only 3 people use it heavily.
### Viktor
- Slack-only for now. Microsoft Teams support is listed as coming soon but is not yet live.
- SOC 2 Type 2 and ISO 27001 certifications are in progress but not yet complete, which can block enterprise procurement.
- Credit-based pricing can be unpredictable. Real-world users report spending $150-400/month above the $50/workspace base, depending on task complexity.
### Duet
- Requires learning a new workspace. Unlike Viktor (Slack) or Claude (existing SaaS), Duet is its own product surface your team has to adopt.
- Smaller brand than OpenAI or Anthropic. Teams that need vendor name recognition for procurement may face internal pushback.
- Multi-model routing is powerful but adds a layer of abstraction. You are trusting Duet's orchestration to pick the right model for each task.
## Pricing: Per-Seat vs Per-Work
- **OpenAI Workspace Agents:** available on any paid ChatGPT tier (Pro $20/mo, Team $30/user/mo, Enterprise). Cost grows with headcount.
- **Claude for Small Business:** per-seat Claude Team or Enterprise. Cost grows with headcount.
- **Viktor:** $50/workspace/month with 20,000 credits, on top of your Slack / Teams subscription. Cost grows with usage.
- **Duet:** monthly plans with included credits, managed by the workspace's designated owner. Paid-reserve topups cover overage.
For a team that wants AI mostly to read and approve, a per-seat plan can be simple to forecast. Duet assigns its monthly subscription and paid reserve to a designated owner, while Viktor uses a workspace plan. Compare current rates against actual workload rather than assuming one shape is always cheaper.
## How to Try Duet
1. Sign up at **[duet.so](/)**.
2. Connect the tools you use. Managed integrations cover Slack, Notion, Linear, Gmail, HubSpot, QuickBooks, and the long tail.
3. Give your AI coworker its first job. Pick a workflow from the [SMB guides](/blog), or just describe the outcome.
4. Schedule the job if it should run every day or every week.
5. Watch the run, inspect the files it produced, and approve any outbound action.
You can have a running AI coworker in the time it takes to read this paragraph twice.
## Frequently Asked Questions
### What is the difference between Duet, OpenAI Workspace Agents, Claude for Small Business, and Viktor?
They all promise an AI coworker, but the shape underneath is different. Duet is a standalone cloud agent workspace with a private server, files, cron, and hosted apps. OpenAI Workspace Agents are agent-mode capabilities inside ChatGPT Business / Enterprise. Claude for Small Business is Anthropic's packaged product with 15 prebuilt workflows and 15 skills, launched May 13, 2026, that lives inside SaaS tools like QuickBooks and HubSpot. Viktor is a per-workspace SaaS agent ($50/workspace/month) that lives inside Slack or Microsoft Teams with 3,000+ integrations, launched in February 2026.
### Which AI coworker is best for a small business in 2026?
It depends on where your work already lives. If your business runs inside QuickBooks and HubSpot, Claude for Small Business is the most packaged answer. If your team lives in Slack or Teams, Viktor fits the lowest-friction shape. If you're already standardized on ChatGPT, OpenAI Workspace Agents is the closest neighbor. If you want one named AI coworker that spans every tool and can also build and host custom apps, Duet is the right shape.
### Does Duet integrate with Slack like Viktor does?
Yes. Duet integrates with Slack through managed integrations, alongside Notion, Linear, Gmail, HubSpot, QuickBooks, and hundreds of other tools. The structural difference is that Duet is a standalone workspace that uses Slack as one of many tools, while Viktor lives inside Slack as its primary surface. Teams that want their AI to participate in Slack threads without losing a private workspace, persistent files, cron jobs, and hosted apps usually prefer Duet.
### Is Claude for Small Business better than OpenAI Workspace Agents?
Neither is universally better. Claude for Small Business is more opinionated for SMBs: 15 prebuilt workflows, 15 skills, first-party connectors into QuickBooks, PayPal, HubSpot, Canva, Docusign, Google Workspace, and Microsoft 365, with human approval required on outbound actions. OpenAI Workspace Agents is broader and assumes your team already uses ChatGPT Business or Enterprise. Pick Claude if you want a packaged SMB answer; pick Workspace Agents if you're already standardized on OpenAI.
### Which of these can actually build and host a custom app?
Duet. Workspace Agents, Claude for Small Business, and Viktor are run-focused: they execute actions and workflows but do not give your team a private server that hosts apps the agent builds. Duet's workspace includes a private cloud server with Node, Python, and Bun, persistent files, cron, and the ability to host any web app the agent builds with a custom domain. That is the "Build and Run" wedge.
### Which is the cheapest for a 5–15 person team?
Per-seat products scale with headcount. Viktor uses workspace pricing with credits. Duet uses monthly plans with included credits and a paid reserve owned by the designated payer. Compare current plans against headcount and expected workload.
---
Source: https://duet.so/blog/enterprise-ai-stack
# What Is an Enterprise AI Stack — and Why Are Enterprises Ditching Single-Vendor AI?
*What is an enterprise AI stack? See the layers, lock-in risks, and a 90-day path enterprises use to go multi-model without a control plane.*
By Duet Team. Published 2026-07-18, updated 2026-07-18. 14 min read.
> An enterprise AI stack is the set of layers that let an organization run production AI—models, data, evaluation, operations, and the work surface where agents, files, and memory live. Multi-model is now the default because no single provider wins every workload. Keep the workspace stable; treat the model as a replaceable choice.
Most people hear "AI stack" and picture a chatbot subscription or a routing dashboard. It's neither. Here's the actual anatomy, the market data behind the shift, and a 90-day path that doesn't start with buying a control plane.
## What is an enterprise AI stack?
An enterprise AI stack is the full set of layers an organization needs to run AI in production: models and inference, data and context, evaluation, operations, and the work surface where agents, files, and memory actually live. Most vendor content stops at layer four.
IDC puts the reframe plainly: "design for a model portfolio, not a single stack." Model choice is one layer, not the whole stack.
| Layer | Job | What must stay portable | Common lock-in | Honest role / boundary |
| --------------------------------------------------- | ---------------------------------------------------- | --------------------------------------------------------- | ------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
| Models / inference | Runs the actual inference calls | The prompt, the eval, the calling code | Provider-tuned prompts and tool-calling that don't port | Not a Duet claim |
| Data & context (RAG, prompts, memory) | Feeds the model what it needs at call time | The retrieval pipeline, prompt templates, memory store | Context trapped in one vendor's proprietary format | Not a Duet claim |
| Evaluation | Measures whether a model actually does the job | The eval suite and its pass/fail history | Leaderboard-chasing instead of internal evals | Not a Duet claim |
| Operations | Tracks spend, access, reliability | Cost data, security policy, logs | Billing and access tied to one vendor's console | Not a Duet claim |
| Work surface (agents, files, memory, collaboration) | Where agents and prior work actually live day to day | The workspace itself — agents, files, memory, team access | Losing years of context when a vendor's terms change | Duet's honest claim: a private workspace where per-agent model choice persists independent of any one provider |
Competitors consistently skip the last layer. It's where agents, files, and memory persist no matter which model answers a given call — the layer that decides whether switching providers costs an afternoon or a quarter. For the tactical, per-task version of this decision, see [choosing the right model for each workload](/blog/how-to-choose-the-right-ai-model-for-your-business).
## Why are enterprises going multi-model now?
Multi-model adoption has already happened, and the driver isn't fear of lock-in — it's that no single provider wins every workload, and the capability frontier moves every quarter.
37% of enterprises now run five or more models, up from 29% the year before ([a16z, 2025](https://a16z.com/ai-enterprise-2025/)). Three vendors — Anthropic, OpenAI, and Google — still account for 88% of enterprise LLM API usage ([Menlo Ventures, 2025](https://menlovc.com/perspective/2025-the-state-of-generative-ai-in-the-enterprise/)).
But _which_ three keeps changing. Anthropic's enterprise LLM share rose from 12% in 2023 to 40% in 2025; OpenAI's fell from 50% to 27%; Google's climbed from 7% to 21% (Menlo Ventures, 2025).
| Vendor | 2023 share | 2025 share |
| --------- | ---------: | ---------: |
| Anthropic | 12% | 40% |
| OpenAI | 50% | 27% |
| Google | 7% | 21% |
_Source: Menlo Ventures, 2025 State of Generative AI in the Enterprise — share of enterprise LLM API usage, not revenue._
a16z asked 100 CIOs why they buy from multiple vendors, and the answer wasn't hedge-your-bets caution: "Model differentiation by use case … is the main reason enterprises buy models from multiple vendors." Betting the whole stack on one provider bets against a frontier that reshuffles every year.
## What is AI vendor lock-in in a multi-model world?
Vendor lock-in used to mean a contract. Now it mostly means a workflow — agentic prompts, tool-calling semantics, and QA tuned so tightly to one provider that switching costs are _rising_, not falling.
An anonymous enterprise leader quoted in a16z's CIO survey put it this way:
> "all the prompts have been tuned for OpenAI. Each one of them has their own set of instructions and prompts and details. How LLMs get instructions to do agentic processing—it takes lots of pages of instruction. Also, quality assurance of agents is not super easy, so changing models is now a task that can take a lot of engineering time."
a16z's own framing backs it up: "the rise of agentic workflows has started making it _more_ difficult to switch between models." A second provider on paper helps less than people assume if the actual switching cost lives in the prompts, not the contract.
Run this audit before your next renewal:
- Where does your context actually live — a portable store, or inside one vendor's product?
- Is your prompt and eval library portable, or hand-tuned to one provider's syntax?
- Do you have a _tested_ offramp for your top provider, not a theoretical one?
- Is any single vendor carrying more than half your production tokens with no fallback plan?
- Could you switch your highest-volume agent to a different model this week, or would it take an engineering sprint?
## Picker vs. router vs. control plane vs. workspace: what do you actually need?
The market collapses four distinct products into "multi-model platform." A model picker, an automatic router, a failover layer, and a governance control plane solve different problems at different maturity levels — and most enterprises need the first one before any of the other three.
| Product class | What it actually does | Who decides | Maturity gate | Honest claim boundary |
| ------------------------ | -------------------------------------------------------------------------- | ---------------------- | -------------------------------------------------------- | ----------------------------------------------------- |
| Model picker | A human assigns a provider/model to an agent or workload | Human | Ship this first | Duet's shipped mechanism — user-controlled, per-agent |
| Auto-router | Software classifies each request and sends it to a model automatically | Software | Add once request volume and patterns are well understood | Not a Duet claim |
| Failover layer | Reroutes to a standby provider automatically during an outage | Software (engineered) | Add once outages carry real cost | Not a Duet claim |
| Governance control plane | Enforces policy, audit, and compliance across every model in use | Software + policy team | Add once you're regulated or auditors ask | Not a Duet claim |
| Coworker workspace | Keeps agents, files, memory, and prior work in one place while models vary | Human, per assignment | Foundational — do this regardless of the rest | Duet's defensible center |
A picker is a human decision: someone assigns a provider and model to an agent, and it persists until reviewed. A router is software making that same call automatically, per request — [our guide to routing between Claude Opus and Sonnet](/guides/claude-opus-vs-sonnet-model-routing) is the concrete single-vendor version of that mechanism.
Failover and governance solve later problems — outages and audits — that most enterprises haven't hit yet. Even [the best AI agent builders](/blog/6-best-ai-agent-builders-in-2026) tend to sell routing or governance tooling as the entry point, because that's the more expensive thing to sell, not because it's what most teams need first.
Anthropic's engineering team frames the underlying spectrum the same way — plain calls, then routing, then full orchestrator-worker systems — and warns that "the most successful implementations use simple, composable patterns rather than complex frameworks" ([Anthropic — Building effective agents](https://www.anthropic.com/engineering/building-effective-agents)).
## What does multi-model actually look like in production?
Real deployments assign models per task, by hand. Nobody serious runs one model for everything, and nobody serious runs a fully automatic router either.
- **Amazon Rufus** pairs an in-house model with Bedrock foundation models, including Nova and Claude, routed by task, serving 250 million users.
- **Intuit Assist / TurboTax** runs Claude for explanations and GPT for Q&A inside a shared human-and-LLM-judge eval pipeline, covering 44 million annual tax returns.
- **CBRE's PULSE** assistant uses Amazon Nova Pro for SQL generation and Claude Haiku for retrieval in one app — 67% faster SQL generation, 60% less token use.
- **Salesforce** packs multiple models onto shared inference endpoints for up to an eightfold reduction in infrastructure cost. The "up to" matters — it's a ceiling, not an average.
Not every attempt goes cleanly. One private university built a [LiteLLM proxy](https://www.zenml.io/llmops-database/privacy-preserving-university-chatbot-with-litellm-proxy-for-multi-model-governance-and-cost-control) to unify multi-model access and hit real friction: delayed support for new provider features, stability issues, and custom workarounds it hadn't budgeted for. That's the honest cost side of "just add a routing layer" — worth knowing before it's your rollout.
None of this is guesswork before it ships. a16z's CIOs were direct about it: "you still need to assess yourself. It's hard to pick without really trialing things and getting employee feedback." Public benchmarks are a first filter, not a decision — we cover the follow-up in [how we benchmark models on real work](/blog/how-we-benchmark-ai-models-on-real-work).
## How do you fix the economics without promising magic savings?
The first real saving is boring, not magical: stop paying for duplicated per-seat subscriptions, and stop defaulting every task to the frontier-tier model.
Enterprise gen-AI spend hit $37 billion in 2025, up 3.2x year over year from $11.5 billion (Menlo Ventures, 2025). This is not small money, and tier-matching is a structural lever inside it, not a routing product.
AWS Prescriptive Guidance frames the tradeoff in dollars: 95% accuracy at $0.50 per conversation versus 90% at $0.05 — a real accuracy difference, and a 10x cost gap to match. Their own guidance: "Don't assume bigger is better."
Tier-matching is already happening at scale, not hypothetical: 67% of OpenAI's own enterprise users have deployed non-frontier models in production, compared with 41% for Google and 27% for Anthropic (a16z, 2025). CIOs consistently tell a16z they'd rather pay by usage than by outcome — tier-matching is what that preference looks like once it ships.
Treat any vendor's flat percentage-savings claim with suspicion unless it shows its cost accounting. "Up to 90% cheaper" without a comparable workload attached is marketing, not math.
## When is a single vendor still the right choice?
Sometimes. A single vendor is entirely rational for a narrow, low-risk, well-bounded deployment — even genuinely multi-model enterprises concentrate most of their usage across just a few providers.
Staying single-vendor makes sense when:
- The deployment is a contained internal tool with a small, known blast radius.
- The pilot is compliance-bounded, with a scope too narrow to justify a second vendor's overhead.
- The team is too small to carry evaluation and prompt-maintenance work across multiple providers.
The argument here isn't against single-vendor pilots. It's against _accidental_ dependence — no offramp, no evals, and organizational context trapped in one vendor's product because nobody planned an exit.
## What does a 90-day multi-model adoption path look like?
Multi-model maturity is a ladder, not a purchase order. Climb it in order — most of the value sits on the first two rungs, and the rest waits until volume and risk justify it.
1. Consolidate work and context in a vendor-neutral workspace.
2. Choose models deliberately per agent or workload, and document why.
3. Evaluate on real internal work, not generic leaderboards.
4. Add routing, failover, and observability only when volume and risk justify the operational tax.
5. Keep an explicit provider offramp at every stage.
The first two rungs are the practical start, where most of the value already lives; the last three are later-stage infrastructure to earn only when volume and risk justify the cost.
This is where a coworker workspace earns its place in the stack. Duet gives every agent the whole frontier — models from OpenAI, Anthropic, xAI, Z.ai and more — and routes each task to whichever one is best at it, while that agent's files, memory, and prior work stay in one private workspace no matter which model answers. There's no governance layer to configure: a person picks a quality tier rather than a model name, that choice persists until someone reviews it, and the whole team works from [one workspace, one bill](/pricing) — a monthly plan with included credits and a paid reserve for overage, rather than a per-seat tax. It's the first two rungs of the ladder above, packaged: consolidate the work, then let the routing hold the quality-versus-cost line. Routing happens inside the tier you chose; nothing here claims to enforce policy across providers or arbitrate spend for you — that's a different, later-stage purchase, and most organizations don't need it yet. What they need is the place the portfolio actually lives.
## Frequently asked questions
### What is an enterprise AI stack?
The full set of layers needed to run AI in production: model access, data and context, evaluation, operations, and the work surface where agents, files, and memory actually live. Most vendor content only covers the first four — the work surface decides whether switching models is easy or painful.
### Does multi-model mean automatic routing?
No. Routing — software classifying a request and sending it to a model — is one workflow pattern, not the definition of multi-model. Only 16% of enterprise deployments qualify as true autonomous agents (Menlo, 2025); most production AI is deliberate, human-assigned selection per task.
### Is multi-model automatically cheaper?
Only if you also do the boring work: cut duplicated per-seat subscriptions, and stop defaulting every task to the frontier-tier model. Tier-matching alone can mean the gap between $0.50 and $0.05 per conversation at comparable accuracy (AWS Prescriptive Guidance). Treat any vendor's flat "savings" claim with skepticism unless it shows its cost accounting.
### Does using more providers automatically make you more resilient?
Not by default. Resilience requires tested failover engineering, which a second provider alone doesn't give you. There's a subtler risk too: agentic workflows can make switching _harder_ even across vendors, because prompts and QA get tuned to one provider's semantics.
### What's the real difference between a model picker and a model router?
A picker is a human decision — someone assigns a provider and model to an agent, and it persists until reviewed. A router is software choosing a model per request, automatically. Most enterprises need a reliable picker long before they need a router.
### Is a single AI vendor ever the right choice?
Yes — for a narrow, well-bounded, low-risk deployment. Even enterprises that call themselves multi-model concentrate most of their usage across just a few providers. The real risk isn't one vendor; it's _accidental_ dependence, with no offramp and no evaluation plan.
### How does a coworker workspace fit into a multi-model stack?
It keeps agents, files, memory, and prior work in one place the organization controls, while each agent's model can be chosen and changed independently — the picker and workspace layers, made real. Not a router, not a governance control plane.
If the ladder above matches how your team already works, the model-picker step is free to start inside a coworker workspace — no router required.
---
Source: https://duet.so/blog/find-dropshipping-suppliers-ai-web-scraping
# Find Reliable Dropshipping Suppliers Using AI
*Bad suppliers kill dropshipping businesses. Use AI to vet, find, and compare reliable suppliers before they cost you customers.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 12 min read.
A bad supplier will kill a dropshipping business faster than a bad product will. Long shipping times, inconsistent quality, poor communication, and stockouts at the worst possible moment — these are supplier problems, and most dropshippers only discover them after they've already scaled a product and burned their ad budget on a broken fulfilment chain.
AI makes supplier evaluation faster, more thorough, and more systematic than the manual approach. Instead of spending hours combing through AliExpress reviews and cross-referencing supplier ratings, you can run a structured evaluation across multiple platforms simultaneously. This guide covers what to look for, how AI scores supplier reliability, the platforms worth evaluating, and how to build the backup supplier system that protects you when your primary supplier fails.
**Quick Summary**
This guide shows how to use AI to find reliable dropshipping suppliers — evaluating quality, shipping times, pricing, and reviews automatically so you can source better products without spending hours vetting suppliers manually.
**Questions this page answers**
- How to find dropshipping suppliers with AI
- Best AI tools for finding dropshipping suppliers
- How to evaluate dropshipping suppliers using AI
- Can AI help find reliable suppliers for dropshipping?
- How to automate supplier research for dropshipping?
## What Does an Unreliable Supplier Actually Cost You?
| Platform | Supplier Type | Vetting Difficulty |
| -------------- | ------------------------- | ----------------------- |
| AliExpress | Manufacturers / resellers | Medium (use AI scoring) |
| CJDropshipping | Warehoused stock | Low (pre-vetted) |
| Spocket | US/EU suppliers | Low |
| Alibaba | Bulk manufacturers | High |
| SaleHoo | Curated directory | Low |
A single bad supplier costs between $50 and $500 per incident. That number compounds fast.
Direct costs per failed order:
That table doesn't include the invisible costs. A single 1-star review lowers conversion rates by 5-10%. Three chargebacks in a month trigger payment processor reviews. Five can get your Stripe account frozen.
27% of online retailers use dropshipping. Competition is dense. Customers who receive a damaged item or wait 30 days for shipping don't come back—they leave reviews.
Most dropshippers discover supplier problems after spending $500-2,000 on ads driving traffic to untested suppliers. By then, the damage is done.
| Validation Step | What to Check | Time Required |
| ------------------------------ | ------------------------------------ | --------------- |
| Order a sample | Quality, packaging, actual ship time | 2-4 weeks |
| Test customer service | Response speed, helpfulness | 1-3 days |
| Check return policy | Refund terms, process | 30 min research |
| Verify product matches listing | Photos vs. real item | On receipt |
Vetting takes time upfront, but it's the only way to avoid the supplier disasters that sink margins.
## Why Does Manual Supplier Research Fail at Scale?
Manual supplier research works when you sell three products. It collapses at 20.
The manual process looks like this:
That process takes 4-8 hours per product. If you're testing 10 products per month, that's 40-80 hours just on supplier vetting—before you've sold anything.
The data also goes stale. A supplier with 4.8 stars today might drop to 4.3 next month. Prices shift weekly. Shipping estimates change with seasonal demand. Stock disappears without notice.
Manual research gives you a snapshot. You need a live feed.
## How to Build an AI-Powered Supplier Research System
This system has four components: data collection, scoring, monitoring, and visualization. Each layer builds on the previous one.
System architecture:
```plaintext
Supplier directories (AliExpress, Alibaba, DHgate, GlobalSources, 1688)
↓ [Web scraping via Firecrawl]
Raw supplier data (prices, reviews, shipping, dispute rates)
↓ [AI scoring model]
Ranked supplier list with composite scores
↓ [Cron-scheduled monitoring]
Change alerts (price increases, rating drops, stockouts)
↓ [Dashboard]
Supplier scorecard with at-a-glance comparisons
```
For a full breakdown of how AI web scraping works under the hood, see How to Scrape, Analyze, and Monitor Any Website.
## Scraping Supplier Data From Multiple Directories
Start by extracting structured data from the five major supplier directories.
What to scrape per supplier:
Scraping across platforms:
- AliExpress: Product pages, store dashboards, review feeds. Richest data for consumer goods.
- Alibaba: Better for bulk pricing. MOQ (minimum order quantity) data helps evaluate scaling costs.
- DHgate: Competitive on electronics and fashion. Fewer reviews, but transaction data is useful.
- GlobalSources: Verified manufacturers. Less consumer data, but better supplier legitimacy signals.
- 1688: Chinese domestic marketplace. Factory-direct prices 20-40% below AliExpress. Requires translation.
DSers uses image recognition to match product photos across platforms, finding factory-direct listings on 1688 that text searches miss. Your scraping system should include reverse image search to replicate this—upload the product image, search 1688 and Alibaba for visual matches, then compare pricing.
Configure Firecrawl extraction prompts to pull structured JSON:
| Prompt Component | What to Include |
| ----------------- | --------------------------------------- |
| Product category | Specific niche (e.g. home fitness gear) |
| Target market | US/EU, specific demographics |
| Quality threshold | Min reviews, fulfilment rate |
| Price range | Target COGS range |
| Red flags | What to exclude (low rating, slow ship) |
```json
{
"supplier_name": "string",
"unit_price_usd": "number",
"bulk_price_100_units": "number",
"shipping_epacket_days": "number",
"store_rating": "number",
"total_reviews": "number",
"negative_feedback_pct": "number",
"store_age_months": "number",
"total_orders": "number",
"warehouse_locations": ["string"]
}
```
For a broader framework on setting up AI-driven research workflows, see How to Use AI as a Personal Research Assistant.
## AI-Powered Supplier Scoring
Raw data is useless without a scoring framework. Build a composite score from five weighted dimensions.
Supplier scoring model:
Feed the scraped data into an AI agent that normalizes each dimension to a 0-10 scale, applies the weights, flags disqualifying signals (dispute rate > 5%, rating < 4.5, store age < 6 months), and ranks all suppliers by composite score.
Example output:
```plaintext
Supplier: ShenZhen TechDirect
Composite Score: 8.7/10
Reliability: 9.2 | Price: 7.8 | Shipping: 9.0 | Reviews: 8.5 | Volume: 8.0
Summary: Top-rated supplier with 38-month track record and 1.2% dispute rate.
US warehouse enables 5-day delivery. Unit price $0.40 above category median
but offset by free ePacket.
Flag: None
```
This replaces 4-8 hours of manual comparison with a ranked list generated in minutes.
For background on building AI-driven research and scoring pipelines, see How to Use AI for Market Research Before Launch.
## Automated Monitoring With Cron Jobs
Finding a good supplier is step one. Keeping them good is the ongoing challenge.
Suppliers change. Prices increase after you commit to a product. Ratings drop during peak seasons when quality control slips. Popular items go out of stock with no warning.
Set up scheduled monitoring on three timelines:
Each cron job compares current results to the last snapshot and triggers alerts on meaningful changes.
Alert thresholds:
- Price increases > 5%: immediate alert
- Rating drops below 4.6: review within 48 hours
- Dispute rate rises above 3%: pause new orders, investigate
- Stockout detected: auto-switch to backup supplier
- Shipping estimate increases > 3 days: notify team
This turns supplier management from reactive firefighting into proactive risk management. You catch problems before your customers do.
For a deep dive on setting up persistent monitoring agents, see How to Set Up a 24/7 AI Agent.
## Building a Supplier Scorecard Dashboard
A dashboard makes supplier performance visible at a glance—a ranked table with color-coded health indicators instead of spreadsheets.
What the dashboard should display:
- Supplier leaderboard: Ranked by composite score, sortable by any dimension
- Health indicators: Green (score > 8), yellow (6-8), red (< 6) badges
- Trend lines: 30-day charts for price, rating, and shipping time
- Alert feed: Recent monitoring alerts with timestamps
- Product mapping: Which products use which supplier (exposure risk)
Dashboard data structure:
```plaintext
┌─────────────────────────────────────────────────────────┐
│ Supplier Scorecard Last updated: │
│ 6 hours ago │
├──────────────────┬───────┬───────┬────────┬─────────────┤
│ Supplier │ Score │ Price │ Ship │ Status │
├──────────────────┼───────┼───────┼────────┼─────────────┤
│ ShenZhen Tech │ 8.7 │ $3.40 │ 5 days │ 🟢 Healthy │
│ GuangZhou Direct │ 8.1 │ $2.90 │ 8 days │ 🟢 Healthy │
│ YiWu Express │ 6.4 │ $2.50 │ 14 days│ 🟡 Watch │
│ FuJian Supply │ 4.2 │ $3.80 │ 22 days│ 🔴 Replace │
└──────────────────┴───────┴───────┴────────┴─────────────┘
```
Host this as a web app that refreshes when cron jobs push new data. Share access with your team or VA so everyone works from the same supplier intelligence.
For a guide to building the full automation dashboard, see How to Build a Dropshipping Automation Dashboard with AI.
## Case Study
### Finding a Supplier With 40% Lower Costs and 3-Day Faster Shipping
The product: Silicone kitchen utensil set (10-piece). Competitive niche, dozens of AliExpress suppliers.
The starting supplier: Found manually. $6.20 unit price, 12-18 day shipping, 4.6 stars, 3.1% dispute rate.
The scraper pulled data from 47 suppliers across AliExpress, Alibaba, and 1688, matched by image and specification comparison.
Top 3 ranked by composite score:
The winner: Supplier #2 on Alibaba. $4.10 unit price (34% savings), US warehouse with 5-7 day shipping (8 days faster), 4.9 rating, 0.9% dispute rate.
Monthly impact at 100 orders:
- Price savings: $210/month ($2.10 x 100)
- Reduced chargebacks: ~$45/month (2 fewer disputes at $15-25 each)
- Higher review scores from faster delivery
The system found this in 15 minutes. The manual search took 6 hours and missed the better option.
For a companion guide on automated product research, see How to Automate Dropshipping Product Research with AI.
## Automating the Full Pipeline on a Cloud Server
The system described above works when run manually from a laptop. It falls apart when you close the lid.
Supplier monitoring needs to run 24/7. Cron jobs need a persistent server. Dashboards need hosting. Running this locally means missed stockout alerts at 3 AM and no dashboard access for your team.
A cloud server solves persistence. But configuring a VPS, setting up cron, deploying a web app, and wiring API calls involves real infrastructure work.
Duet handles this stack in one place. It runs a persistent AI agent with built-in web scraping (Firecrawl), cron scheduling, and app hosting. You describe the supplier research pipeline in natural language, Duet builds and runs it, and the dashboard stays live on a hosted URL. No server configuration, no deployment scripts, no separate hosting bill for the dashboard.
The entire supplier research system runs as a single automated workflow. You interact through chat when you need to add products or adjust scoring weights.
For a walkthrough on building a price monitoring layer alongside supplier research, see How to Build a Dropshipping Price Monitor with AI Alerts.
## Frequently Asked Questions
### How many suppliers should I vet before choosing one?
Vet a minimum of 15-20 suppliers per product. The automated scraping system can evaluate 40-50 in the same time it takes to manually check 5. More data points produce more reliable composite scores. Always order samples from your top 3 before committing to volume orders—data vetting reduces the sample pool, not replaces physical verification.
### Which supplier directory is best for dropshipping beginners?
AliExpress is the best starting point. It has the richest review data, lowest MOQs (often single-unit), and built-in buyer protection. Alibaba offers better bulk pricing but requires minimum orders of 50-500 units. DHgate sits in between. Once you're doing 200+ units per month, scrape 1688 through a sourcing agent for factory-direct pricing 20-40% below AliExpress.
### How often should I re-evaluate my existing suppliers?
Run automated checks weekly at minimum. Daily stock and price checks catch urgent issues. Weekly rating and review monitoring catches gradual quality decline. Monthly full re-scoring against the broader market identifies when a better supplier has emerged. The cron-based system handles all of this without manual effort.
### Can AI detect fake reviews on supplier pages?
AI sentiment analysis catches several fake review patterns: identical phrasing across reviews, review bursts (50 reviews in one day), mismatched star ratings and text sentiment, and generic language with no product-specific details. It isn't perfect—sophisticated fakes slip through—but it flags obvious manipulation that manual scanning misses, especially across 40+ suppliers.
### What dispute rate is acceptable for a dropshipping supplier?
Keep your suppliers below 2% dispute rate. Between 2-3% is a warning zone—monitor weekly and have a backup ready. Above 3% means active customer complaints that will impact your store's reputation. For context, top-tier AliExpress suppliers maintain dispute rates between 0.5% and 1.5%. The scoring model flags anything above 2% automatically.
### How do I handle suppliers that suddenly raise prices?
The daily price monitoring cron job catches increases immediately. Set alert thresholds at 5% for notification and 10% for automatic backup supplier activation. When a price increase hits, the system can automatically re-run the scoring pipeline across all scraped alternatives, giving you a ranked list of replacements within minutes instead of starting a new manual search.
### Is web scraping supplier directories legal?
Scraping publicly available data (prices, ratings, reviews visible to any visitor) is generally permitted. Avoid scraping behind login walls, circumventing access controls, or violating a site's Terms of Service. AliExpress and Alibaba rate-limit aggressive scraping, so use respectful intervals (2-5 seconds between requests) and rotate requests across time windows. Firecrawl handles rate limiting and compliance automatically.
---
Source: https://duet.so/blog/frontier-model-orchestrator
# Orchestrator-Worker LLMs vs. Model Routing: Which One Actually Cuts Your AI Costs?
*Orchestrator-worker patterns boost quality, not cost. Model routing cuts spend. Anthropic and RouteLLM data on which lever to pull, and when.*
By Duet Team. Published 2026-07-18, updated 2026-07-18. 13 min read.
> **The orchestrator-worker pattern uses a capable "frontier" model to decompose a complex task, delegate subtasks to cheaper worker models, and synthesize the results. It is a quality/capability pattern — not, by itself, a cost-saving one. The cost savings come from a separate mechanism, model routing: sending easy requests to a cheap model and hard ones to a strong model.**
Most people hear "orchestrator" and assume cheaper. It doesn't. Here's what each mechanism actually does, what it costs, and which one to reach for.
## What is the orchestrator-worker pattern?
The orchestrator-worker pattern is one frontier model breaking a complex task into pieces, handing each to a worker model, and stitching the results into one answer. [Anthropic's "Building effective agents" defines the orchestrator-worker pattern](https://www.anthropic.com/engineering/building-effective-agents) as the canonical version of this architecture.
A central LLM — the orchestrator — dynamically decomposes the task, writes a self-contained brief for each subtask, dispatches it to worker LLMs, then synthesizes their outputs. Anthropic's production version is what it calls a "multi-agent system": one lead model plus subagents, same architecture, different name.
That's narrower than the broader term LLM orchestration usually covers. This article is specifically about who does which work and what that costs — not the wider stack of evals, memory, and guardrails "orchestration" sometimes gets stretched to mean.
## Is an orchestrator the same thing as a model router?
No. Orchestrator-worker is a quality lever; model routing is a cost lever. An orchestrator answers "how do I do work one agent can't handle alone?" by fanning one task out to many models. A router answers "which single model should answer this request?" by picking exactly one. Fan-out versus single-pick is the whole distinction.
| Dimension | Orchestrator-worker | Model routing |
| ----------------- | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------- |
| Question answered | How do I do work one agent can't? | Which model should answer this one request? |
| Mechanism | Decompose → delegate → synthesize | Classify → send to exactly one model |
| Models per task | Many (fan-out) | One per request |
| Effect on quality | Raises the ceiling — +90.2% outperformance vs. a single-agent baseline on Anthropic's internal research eval | Holds a chosen floor — 87–95% of strong-model quality (RouteLLM, benchmark-dependent) |
| Effect on tokens | Increases — roughly 15× a single chat turn | Decreases — 1.41×–3.66× cheaper at that quality floor (RouteLLM) |
| Effect on latency | Cuts wall-clock time via parallel work — up to 90% faster on complex research | Adds a small classification step; otherwise unchanged |
| Best fit | Ambiguous, parallelizable, high-value tasks | Heterogeneous traffic with a measurable easy/hard split |
| Primary evidence | Anthropic, multi-agent research system | RouteLLM (arXiv:2406.18665) |
They compose — an orchestrator's own workers can each be routed to a cheap model for their bounded subtask. But composition doesn't merge the claims: two separate levers, not two names for the same thing.
## Does orchestrator-worker reduce LLM cost?
Usually not — it typically costs more. Orchestration is priced in tokens, and decomposition multiplies them: Anthropic's own numbers put agents at roughly 4× the tokens of a single chat turn, multi-agent systems at roughly 15×. Every worker gets its own full context window, the lead plans and re-reads results, and synthesis bills on top.
Orchestration is the price of a capability a single agent can't reach — not a savings mechanism. If someone pitches "add an orchestrator to cut your bill," that's the exact conflation this article exists to correct.
## What did Anthropic actually measure?
A multi-agent system with Claude Opus 4 as the lead and Claude Sonnet 4 subagents [outperformed single-agent Claude Opus 4 by 90.2% on Anthropic's internal research eval](https://www.anthropic.com/engineering/multi-agent-research-system) — using roughly 15× the tokens of a single chat turn to get there.
That gain wasn't clever delegation so much as tokens: three factors explained 95% of the performance variance on Anthropic's BrowseComp evaluation, with token usage alone explaining 80% of it. Multi-agent architecture is, mechanically, a way to spend past one context window's limit.
Anthropic names where the pattern is a poor fit — and where the 90.2% figure doesn't transfer:
- **Most coding tasks** — fewer subtasks that can genuinely run in parallel.
- **Work needing shared context across agents**, or heavy dependencies between them.
- **Anything requiring real-time delegation** — agents aren't yet reliably good at it.
## How much can model routing actually save?
[RouteLLM achieved 3.66× cost savings at 95% of GPT-4 quality on MT-Bench](https://arxiv.org/html/2406.18665v4) — under 2024 pricing (GPT-4-1106 at $24.70 per million tokens vs. Mixtral 8x7B at $0.24). Use the ratio, not the dollar figures; prices have moved since.
| Benchmark | Cost cut vs. all-GPT-4 | Quality retained |
| -------------------------- | ---------------------: | ---------------: |
| MT-Bench (open-ended chat) | 3.66× | 95% |
| GSM8K (math) | 1.49× | 87% |
| MMLU (knowledge) | 1.41× | 92% |
Savings are benchmark-dependent, not a fixed multiplier — the easier your workload looks to a small model, the steeper your curve. RouteLLM's best router (matrix factorization, trained on 65K Chatbot Arena comparisons) generalized to Claude 3 and Llama 3.1 pairs it never trained on: "how hard is this query" is learnable structure, not model trivia.
That's what multi model routing means: one small classifier deciding, per request, whether a cheap or strong model answers — never a group of models on one task together. For a narrower look at [routing within the Claude model family](/guides/claude-opus-vs-sonnet-model-routing) — Haiku, Sonnet, and Opus against each other — see our related guide; it's conceptual, not a description of any product's automation.
## How do you decide which tasks go to which model tier?
Go multi-agent only if all four conditions hold. Otherwise, tier your tasks and route down wherever a cheap model already clears your bar.
Reach for orchestrator-worker only when:
1. Subtasks can't be listed in advance (otherwise, just fix-parallelize them).
2. The work is breadth-first — workers run in parallel, not sequentially.
3. A correct answer is worth comfortably more than ~15× chat tokens.
4. Each worker gets a self-contained brief, with no shared-context dependency.
Miss one, and Anthropic and OpenAI agree on the fallback: stay with a single well-prompted agent.
| Tier | Task shape | Example |
| ----------------------------- | --------------------------------------------- | -------------------------------------------------- |
| Frontier / orchestrator-class | Ambiguous decomposition, high-stakes judgment | Research strategy, "should we approve this" |
| Mid / balanced | Bounded reasoning, clear success criteria | Drafting from a brief, single-file code diffs |
| Cheap / fast | Extraction, classification, formatting | "Pull the dates from this email," reformat to JSON |
OpenAI's guidance is blunt: prototype every task with your most capable model to set a baseline, then swap in smaller models and keep whichever pass your evals.
This mapping is most of the real work behind [choosing the right AI model for your business](/blog/how-to-choose-the-right-ai-model-for-your-business). Measure each tier the way we describe in [how we benchmark models on real work](/blog/how-we-benchmark-ai-models-on-real-work): task success, total cost including retries, and escalation rate, on 30–50 representative tasks.
## What does the math actually look like?
Run the numbers on published prices, not vibes. This is arithmetic, not a benchmark — using Anthropic's live API rates as of July 2026.
| Model | Input | Output |
| ------------------------------------- | --------: | ---------: |
| Opus 4.8 | $5 / MTok | $25 / MTok |
| Sonnet 5 (intro, through Aug 31 2026) | $2 / MTok | $10 / MTok |
| Haiku 4.5 | $1 / MTok | $5 / MTok |
Opus 4.8 to Haiku 4.5 is a 5× spread on one vendor's price list. RouteLLM's 2024 experiment used a roughly 100× cross-vendor spread (GPT-4-1106 vs. Mixtral 8x7B) — part of why its savings looked so large. Smaller spread, shallower savings curve, same routing accuracy.
Blend your traffic across tiers and savings show up directly. At a 20/30/50 split across Opus, Sonnet, and Haiku input prices: `0.2×$5 + 0.3×$2 + 0.5×$1 = $2.10 per million tokens`, against $5.00 all-Opus — a 2.4× reduction before retries. That's arithmetic on prices published in July 2026, not a measured benchmark; your traffic mix will move the number.
Keep the other side of the ledger in view: run that same task as a multi-agent system instead, and Anthropic's data says budget about 15× the tokens, not a fraction. Routing and orchestration pull your bill in opposite directions.
## When is a premium seat still the right call?
It depends on who's using it. A flat-rate seat can look cheaper for one heavy user. For a whole team, a monthly plan with included credits and a paid reserve for overage is usually the cheaper shape, because the overage is priced rather than bought a seat at a time.
| Who's using it | Premium seat (flat rate) | Raw API (pay per token) | Tiered workspace (routed by role) |
| -------------------------- | ------------------------------------------------------------------- | --------------------------------------------------------------- | -------------------------------------------------------------------------- |
| One heavy interactive user | Wins — metered usage would likely exceed the seat price | Depends on volume; can spike past seat cost fast | Depends on mix — overkill if the work is frontier-grade all day anyway |
| Heterogeneous team | Loses by default — most seats sit idle or underused most of the day | Depends on mix — no floor on a runaway single request | Wins — frontier only where judgment is scarce, cheap tiers absorb the rest |
| Production workload | Loses by default — seats don't scale with request volume | Depends on mix — needs its own routing discipline to stay cheap | Wins — cost tracks usage per model, matched to task tier |
None of that makes a $200-class seat a bad deal for one person running interactive work all day. It's the wrong _default_ for a team with a mix of trivial and hard work, where you'd otherwise pay the frontier rate for every role.
## How do you actually build this without a router project?
You don't build a router. You configure tiers once, in the same place you already define the work.
Cross-vendor choices work the same way: [route between two frontier models without lock-in](/blog/grok-4-5-vs-claude-opus-4-8) for the orchestrator role, or [pick the model and thinking depth per agent](/blog/claude-opus-4-7-gpt-5-4-extended-thinking-duet) for one step — neither needs new infrastructure.
In practice, most teams don't want to write a router — they want the choice already sitting in their tools. That's the honest version of what Duet does today: model tiers (frontier, balanced, fast) are a first-class part of the workspace config, not a separate infrastructure project.
Assign the orchestrator role to a frontier model, pin the bounded worker steps to a balanced or fast tier, and every model shares the same files, memory, and work history — you're not re-explaining context every time you change which model handles a step.
What Duet doesn't do is auto-classify every request by difficulty and route it for you; there's no learned router sitting in front of the harness. The tiering is a decision you make once, in config, not a judgment call the system makes per query.
Usage is billed at a flat rate per quality tier rather than per seat, so the tier you choose and the bill you get are the same artifact. See [Duet's pricing page](/pricing) for current rates.
## Frequently asked questions
**Is orchestrator-worker the same as multi-agent systems?**
Yes. "Multi-agent system" is Anthropic's term for a production version of the orchestrator-worker pattern — a lead model plus subagents. Same architecture, two names.
**Does adding more agents always improve output quality?**
No. Anthropic saw early agents spawn 50 subagents for a simple query, and [a 2026 Lancaster University study of a 26-model orchestrator](https://arxiv.org/html/2512.01099v2) found over-decomposition raised resource cost from 65 J to 224 J — roughly 3.4× — on one task, while accuracy collapsed to 20.1% versus 92.3% for the correct single-task run; popularity-biased selection also picked the same dominated model every time for image captioning. More models, and letting a model pick its own teammates, are liabilities unless the task is genuinely parallel and measured.
**What's the real cost difference between orchestration and routing?**
Orchestration costs about 15× a single chat turn's tokens — the lead's plan, every worker's context, and synthesis all bill separately. Routing goes the other way: one model per request, so cost drops — RouteLLM measured 3.66× lower cost at 95% of GPT-4 quality on MT-Bench, under 2024 pricing.
**Can you use orchestration and routing together?**
Yes — they compose. A frontier model acts as orchestrator while each worker's own call is routed to a cheap or mid-tier model for its bounded subtask. One mechanism structures the task; the other picks which model answers a given call.
**Do I need the $200/month plan to use a frontier model as an orchestrator?**
Not necessarily. A premium seat wins for one heavy user whose metered usage would cost more. For a mixed-workload team, a frontier orchestrator plus cheaper-tier workers, billed by usage, is usually the better-structured spend — just the wrong default for a heterogeneous team.
**When should I not bother with an orchestrator-worker setup?**
When subtasks can't be enumerated in advance, the work isn't genuinely parallelizable, you can't give each worker a self-contained brief, or a more complete answer isn't clearly worth ~15× the tokens. Anthropic and OpenAI both recommend maximizing one well-prompted agent first.
**How much can model routing actually save on my workload?**
It depends on task distribution, not a fixed number — RouteLLM ranged from 1.41× at 92% quality on MMLU to 3.66× at 95% of GPT-4 quality on MT-Bench, under 2024 pricing. Run evals on 30–50 representative tasks and measure cost per successful outcome, including retries.
---
Source: https://duet.so/blog/gemini-3-pro-vs-claude-opus-4-8
# Gemini 3 Pro vs Claude Opus 4.8: The Complete Guide 2026
*Gemini 3 Pro vs Claude Opus 4.8 compared on coding, reasoning, speed, and price. See which model wins each task and when to route between them.*
By Duet Team. Published 2026-07-20, updated 2026-07-20. 9 min read.
Gemini 3 Pro and Claude Opus 4.8 are the two models most teams weigh when they want a frontier model in 2026.
Before the numbers, one clarification that matters: Gemini 3 Pro's current release is Gemini 3.1 Pro. Google is [retiring the original 3 Pro Preview](https://discuss.ai.google.dev/t/migrate-from-gemini-3-pro-preview-to-gemini-3-1-pro-preview-before-march-9-2026/127062) and moving everyone to 3.1 Pro, so every Gemini figure below is the shipping 3.1 Pro, the model you actually get when you call Gemini 3 Pro today.
**Neither model wins outright. Claude Opus 4.8 is the stronger agentic coder. Gemini 3 Pro is faster and cheaper. For most teams the right answer is not to pick one, it is to route each task to the model that owns it.**
Here is the short version:
- **Reach for Claude Opus 4.8** when the work is hard agentic coding, multi-file refactors, or anything where reliability matters more than cost.
- **Reach for Gemini 3 Pro** when you need speed, low cost, high volume, or multimodal input.
- **Use both** when your workload is mixed, which describes almost every real product.
## The 30-second verdict
Claude Opus 4.8 is the sharper engineer. It leads on the coding and agentic benchmarks that predict how an autonomous agent behaves across a real codebase, and it makes fewer confident mistakes. Anthropic ships it with a [1M token context window](https://llm-stats.com/blog/research/claude-opus-4-8-launch) and dynamic parallel-subagent workflows in Claude Code, built for migrations that span an entire repo.
Gemini 3 Pro is the faster, cheaper generalist. It runs [roughly twice as fast and about 2.5x cheaper on input](https://artificialanalysis.ai/models/comparisons/claude-opus-4-8-vs-gemini-3-1-pro-preview), matches Opus on context window, and carries Google's multimodal strength for image and video input. For high-volume pipelines where you are paying per token at scale, that price and speed gap compounds fast.
The old tiebreaker used to be context window. That is gone. Both models now ship a 1M token window, so the deciding factor is no longer how much you can load, it is how well each model thinks across what you load.
## Benchmarks, head to head
Every number here is the vendor-reported or standardized figure for the current shipping model, linked to its source.
| Dimension | Gemini 3 Pro (3.1 Pro) | Claude Opus 4.8 | Edge |
| --- | --- | --- | --- |
| Context window | [1M tokens](https://deepmind.google/models/model-cards/gemini-3-1-pro/) | [1M tokens](https://llm-stats.com/blog/research/claude-opus-4-8-launch) | Tie |
| SWE-bench Verified | [80.6%](https://www.vellum.ai/blog/google-gemini-3-benchmarks) | [88.6%](https://benchlm.ai/models/claude-opus-4-8) | Opus 4.8 |
| GPQA Diamond | [94.3%](https://www.vellum.ai/blog/google-gemini-3-benchmarks) | ~94% (within a point) | Tie |
| ARC-AGI-2 (novel reasoning) | [77.1%](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-3-1-pro/) | not published | Gemini 3 Pro |
| Intelligence Index (Artificial Analysis) | [46](https://artificialanalysis.ai/models/comparisons/claude-opus-4-8-vs-gemini-3-1-pro-preview) | [56](https://artificialanalysis.ai/models/comparisons/claude-opus-4-8-vs-gemini-3-1-pro-preview) | Opus 4.8 |
| Output speed | [~129 tokens/sec](https://artificialanalysis.ai/models/comparisons/claude-opus-4-8-vs-gemini-3-1-pro-preview) | [~60 tokens/sec](https://artificialanalysis.ai/models/comparisons/claude-opus-4-8-vs-gemini-3-1-pro-preview) | Gemini 3 Pro |
| Price (input / output per 1M) | [$2 / $12](https://openrouter.ai/google/gemini-3.1-pro-preview) | [$5 / $25](https://www.finout.io/blog/claude-opus-4.8-pricing-2026-everything-you-need-to-know) | Gemini 3 Pro |
Read the table as two clusters. Opus 4.8 owns raw coding accuracy and the composite intelligence score. Gemini 3 Pro owns speed and price. On knowledge reasoning like GPQA the two are inside the margin of error, and on the ARC-AGI-2 novel-reasoning test Gemini pulls ahead. The window is a wash.
## Where Claude Opus 4.8 pulls ahead
Opus 4.8 is the model to trust with an autonomous coding agent. It scores [88.6% on SWE-bench Verified](https://benchlm.ai/models/claude-opus-4-8) against [Gemini's 80.6%](https://www.vellum.ai/blog/google-gemini-3-benchmarks), an eight-point gap on the benchmark that best tracks resolving real GitHub issues. On the harder [SWE-bench Pro it reaches 69.2% and Terminal-Bench 2.1 hits 74.6%](https://llm-stats.com/blog/research/claude-opus-4-8-launch), the kind of long-horizon terminal work that breaks weaker agents.
The gap that does not show up in a single number is reliability. In cross-file work, Opus 4.8 traces dependencies that span files and resists inventing change points that were not actually there, while Gemini 3 Pro is more likely to produce a false positive and suggest edits to files that did not need touching. For an agent running unattended, a confident wrong edit is worse than a slow one.
Opus 4.8 also leads the [Artificial Analysis Intelligence Index at 56 to Gemini's 46](https://artificialanalysis.ai/models/comparisons/claude-opus-4-8-vs-gemini-3-1-pro-preview), and it ships parallel-subagent workflows in Claude Code, where the model spawns subagents that each plan, execute, and verify a slice of a large task and report to an orchestrator. That is built for codebase-scale migrations, not single-file edits.
## Where Gemini 3 Pro wins
Gemini 3 Pro wins on the economics of running a model at scale. It generates [about 129 tokens per second to Opus 4.8's 60](https://artificialanalysis.ai/models/comparisons/claude-opus-4-8-vs-gemini-3-1-pro-preview), so interactive and streaming workloads feel noticeably snappier. And it lists at [$2 input and $12 output per million tokens](https://openrouter.ai/google/gemini-3.1-pro-preview) against Opus 4.8's [$5 and $25](https://www.finout.io/blog/claude-opus-4.8-pricing-2026-everything-you-need-to-know), roughly 2.5x cheaper on input. Across a pipeline that processes millions of tokens a day, that is the difference between a viable unit economic and a bleeding one.
It is also the stronger novel reasoner on ARC-AGI-2, where it [jumped to 77.1%](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-3-1-pro/) in this release, and it carries Google's multimodal lineage for image and video understanding. If your product feeds the model screenshots, documents, or frames, Gemini 3 Pro is the natural default.
## Context and multimodal
Because both models now sit at a 1M token window, long-context capacity is no longer a reason to pick one over the other. What differs is what each does best inside that window. Gemini 3 Pro leans into mixed media, reading images and video alongside text.
Opus 4.8 leans into code, holding a large repository in context and reasoning across files without losing the thread. Match the window to the payload: media-heavy work to Gemini, code-heavy work to Opus.
## Which should you actually use?
Skip the leaderboard and map it to the job:
- **Agentic coding, multi-file refactors, repo migrations:** Claude Opus 4.8.
- **High-volume summarization, extraction, classification, chat:** Gemini 3 Pro.
- **Cost-sensitive or latency-sensitive pipelines:** Gemini 3 Pro.
- **Reliability-critical work an agent runs unattended:** Claude Opus 4.8.
- **Multimodal input, image or video:** Gemini 3 Pro.
- **Hard knowledge reasoning:** close enough to test both on your own prompts.
Notice that the list splits down the middle. That is the point. A real workload is a mix of hard coding, cheap high-volume calls, and the occasional multimodal task, and no single model is the right pick for all three.
## You don't have to choose: route between them
The honest conclusion of every frontier-model comparison in 2026 is the same.
The best setup is not one model, but the right model per task. We reached the same verdict comparing [Opus 4.8 to Grok 4.5](/blog/grok-4-5-vs-claude-opus-4-8): route, don't marry.
The catch is that running both yourself means two API accounts, two billing relationships, two SDKs, and a layer of routing glue you have to build and maintain. That is real engineering time spent on plumbing instead of product.
This is what Duet is for. Duet runs Claude Opus and Gemini in one managed workspace and sends each task to the model that wins it, so you get Opus 4.8 for the hard agentic coding and Gemini 3 Pro for the cheap high-volume work without wiring the routing yourself. You can even [run Claude Code in the cloud](/blog/how-to-run-claude-code-in-the-cloud) on the same workspace, persistent and resumable from any device.
**Want both models behind one workspace? [Try Duet free](https://app.duet.so/sign-in?from=blog-gemini-vs-opus).** No two accounts, no routing code, no per-model glue.
## Frequently Asked Questions
### Is Gemini 3 Pro better than Claude Opus 4.8?
Neither is better across the board. Claude Opus 4.8 leads on agentic coding and overall intelligence score, while Gemini 3 Pro is faster, cheaper, and stronger on multimodal input. The better model depends on the task, which is why many teams route between them.
### Which is better for coding, Gemini 3 Pro or Claude Opus 4.8?
Claude Opus 4.8. It scores 88.6% on SWE-bench Verified to Gemini 3 Pro's 80.6%, leads on harder agentic benchmarks like Terminal-Bench, and makes fewer confident cross-file mistakes, which matters most when an agent runs unattended.
### Which model has the bigger context window?
They tie. Both Gemini 3 Pro (3.1 Pro) and Claude Opus 4.8 ship a 1M token context window, so window size is no longer a deciding factor between them.
### Is Claude Opus 4.8 better for agentic tasks?
Yes. Opus 4.8 leads the agentic coding benchmarks and ships parallel-subagent workflows in Claude Code that plan, execute, and verify slices of large tasks. Its cross-file reliability makes it the safer choice for autonomous agents.
### How much does each model cost?
Gemini 3 Pro lists at $2 per million input tokens and $12 per million output tokens. Claude Opus 4.8 lists at $5 input and $25 output. Gemini is roughly 2.5x cheaper on input, which compounds at high volume.
### Which model is faster?
Gemini 3 Pro. It generates around 129 tokens per second to Claude Opus 4.8's roughly 60, so it feels faster in interactive and streaming use.
### Can I use Gemini 3 Pro and Claude Opus 4.8 together?
Yes, and for most teams that is the strongest setup. You can call each model's API directly and build your own routing, or use a workspace like Duet that runs both and routes each task to the model that fits it.
### Which is better for writing and long-form content?
They are close. Both handle long-form well within their 1M windows. Gemini 3 Pro is faster and cheaper for high-volume drafting, while Opus 4.8 tends to hold a more consistent voice across very long documents. Test both on your own style.
## Keep reading
- [Grok 4.5 vs Claude Opus 4.8](/blog/grok-4-5-vs-claude-opus-4-8): the same route-between-them verdict on a different matchup.
- [How to run Claude Code in the cloud](/blog/how-to-run-claude-code-in-the-cloud): put Opus 4.8 on a persistent cloud workspace.
- [Claude Code vs Cursor vs Codex](/blog/claude-code-vs-cursor-vs-codex): pick the right AI coding tool, not just the right model.
- [Codex vs Claude Code](/blog/codex-vs-claude-code): features, benchmarks, and which agent to use.
---
Source: https://duet.so/blog/grok-4-5-vs-claude-opus-4-8
# Grok 4.5 vs Claude Opus 4.8: Which Should You Actually Use in 2026?
*Grok 4.5 vs Claude Opus 4.8 compared: pricing, coding benchmarks, context windows, and reliability. Plus the smarter way to run or route between both without lock-in.*
By Duet Team. Published 2026-07-13, updated 2026-07-20. 10 min read.
## The short answer
**If you're optimizing for cost and running high-volume agentic work, use Grok 4.5. If you need the strongest coding and long-horizon reasoning, use Claude Opus 4.8.** On the coding benchmark where both vendors report scores, SWE-bench Pro, Opus 4.8 leads 69.2% to Grok 4.5's 64.7% ([Vellum](https://www.vellum.ai/blog/claude-opus-4-8-benchmarks-explained), [Developers Digest](https://www.developersdigest.tech/blog/grok-4-5-for-developers)), and on overall intelligence they're close (56 vs 54 on the Artificial Analysis Intelligence Index). But Grok undercuts Opus by roughly 60% on input and 76% on output pricing ([Anthropic](https://www.anthropic.com/news/claude-opus-4-8), [InfoWorld](https://www.infoworld.com/article/4194895/spacexai-launches-grok-4-5-touts-lower-coding-task-costs-than-ai-rivals.html)), and it runs far more token-efficiently. For most teams the honest answer isn't "pick one," it's use the right one per task, which is a setup decision, not a model decision. More on that below.
---
## What just happened
The frontier-model race hit a new inflection in July 2026. On July 8, xAI (SpaceXAI) shipped **Grok 4.5**, which Elon Musk described as an "Opus-class model" at less than half the price of comparable Anthropic models ([TechCrunch](https://techcrunch.com/2026/07/08/spacexai-releases-grok-4-5-which-elon-describes-as-an-opus-class-model/)). xAI positions it as its "smartest model built to excel at coding, agentic tasks, and knowledge work" ([x.ai](https://x.ai/news/grok-4-5)).
On the other side, **Claude Opus 4.8** is generally available and now hosted on Microsoft Foundry ([EdTech Innovation Hub](https://www.edtechinnovationhub.com/news/anthropic-brings-claude-to-microsoft-foundry-with-azure-hosting-and-governance-controls)), and Anthropic has been busy. It also shipped a lower-cost **Sonnet 5** on June 30 at $2/M input introductory pricing, through Aug 31; the standard rate is $3/$15 ([The Journal](https://thejournal.com/articles/2026/07/08/anthropic-intros-lower-cost-claude-sonnet-5.aspx)).
So the obvious question everyone's asking: Grok 4.5 or Opus 4.8, which one should I actually use? Let's compare them honestly, then talk about the setup that makes the choice a lot less permanent.
---
## Grok 4.5 vs Claude Opus 4.8: the head-to-head
| | **Grok 4.5** (xAI) | **Claude Opus 4.8** (Anthropic) |
| -------------------------------------------- | ---------------------------------------------------- | ----------------------------------------------------------- |
| **Input price** | **$2 / M tokens** | $5 / M |
| **Output price** | **$6 / M tokens** | $25 / M |
| **SWE-bench Pro** | 64.7% | **69.2%** |
| **Intelligence Index** (Artificial Analysis) | 54 | **56** |
| **Context window** | 500K tokens | 1,000,000 tokens |
| **Token efficiency** | **~4.2x fewer output tokens/task** | baseline |
| **Released** | July 8, 2026 | GA (also on MS Foundry) |
| **Best at** | Cost efficiency, agentic and high-volume work | Coding reliability, long-horizon reasoning, largest context |
| **Watch-out** | New; $2/$6 applies under 200K context, doubles above | Recent reliability strain (see below) |
Sources: pricing, [Anthropic](https://www.anthropic.com/news/claude-opus-4-8) and [InfoWorld](https://www.infoworld.com/article/4194895/spacexai-launches-grok-4-5-touts-lower-coding-task-costs-than-ai-rivals.html); Grok tiered pricing above 200K, [Developers Digest](https://www.developersdigest.tech/blog/grok-45-xai-cursor-coding-model); SWE-bench Pro, [Vellum](https://www.vellum.ai/blog/claude-opus-4-8-benchmarks-explained) (Opus 69.2%) and [MarkTechPost](https://www.marktechpost.com/2026/07/08/spacexai-releases-grok-4-5/) (Grok 64.7%); Intelligence Index and token efficiency, [Artificial Analysis](https://artificialanalysis.ai/articles/grok-4-5-brings-spacexai-to-the-the-intelligence-frontier); context windows, Grok 500K via Artificial Analysis, Opus 1M via [Price Per Token](https://pricepertoken.com/pricing-page/model/anthropic-claude-opus-4.8).
> Note: Opus 4.8 also posts **88.6% on SWE-bench Verified**, up from Opus 4.7's 87.6% ([Vellum](https://www.vellum.ai/blog/claude-opus-4-8-benchmarks-explained)). Grok 4.5 doesn't publish a comparable SWE-bench Verified number, so the head-to-head above uses SWE-bench Pro, where both vendors report scores.
### Price
This is Grok's headline. At **$2 input / $6 output**, it undercuts Opus 4.8's **$5 / $25** by a wide margin, and the gap widens on output, which dominates real agent workloads. Grok's pricing does have a catch: the $2/$6 rate covers contexts under 200K tokens and roughly doubles above that ([Developers Digest](https://www.developersdigest.tech/blog/grok-45-xai-cursor-coding-model)). Opus also offers a premium fast mode for latency-sensitive work.
**Verdict:** Grok 4.5, decisively, especially for high-token, high-volume agent runs.
### Coding and reasoning
On SWE-bench Pro, the coding benchmark where both xAI and Anthropic report scores, **Opus 4.8 leads at 69.2%, with Grok 4.5 at 64.7%** ([Vellum](https://www.vellum.ai/blog/claude-opus-4-8-benchmarks-explained), [MarkTechPost](https://www.marktechpost.com/2026/07/08/spacexai-releases-grok-4-5/)). On the broader Artificial Analysis Intelligence Index the two are close, Opus 4.8 at 56 and Grok 4.5 at 54. Anthropic still tends to win on long-horizon, multi-step reasoning where reliability compounds; Grok's counterweight is efficiency, xAI reports it uses roughly 4.2x fewer output tokens per task on agentic coding ([MarkTechPost](https://www.marktechpost.com/2026/07/08/spacexai-releases-grok-4-5/)).
**Verdict:** Opus 4.8 for top coding reliability; Grok 4.5 for near-frontier results at a fraction of the token cost.
### Context window
Opus 4.8 carries a **1M-token** context ([Price Per Token](https://pricepertoken.com/pricing-page/model/anthropic-claude-opus-4.8)); Grok 4.5 ships with **500K**, actually a reduction from Grok 4.3's 1M ([Artificial Analysis](https://artificialanalysis.ai/articles/grok-4-5-brings-spacexai-to-the-the-intelligence-frontier)). For very large single-pass repos or document sets, Opus has the edge.
**Verdict:** Opus 4.8 for the largest working sets; 500K is plenty for most tasks.
### Reliability
Worth flagging honestly: Anthropic went through a rough patch, with reporting of **ten significant service disruptions in twelve days** in June 2026, including Opus 4.8 errors ([TechTimes](https://www.techtimes.com/articles/318514/20260616/claude-outage-tenth-disruption-12-days-exposes-anthropic-infrastructure-strain.htm)). Grok 4.5 is newer and less battle-tested at scale. Neither is a clean win, and it's a reminder that single-provider dependency is itself a risk.
---
## Grok 4.5 vs Opus 4.8 in Cursor
Both models are selectable in Cursor, so the same tradeoff plays out inside the IDE. Pick **Opus 4.8** when coding reliability matters most (SWE-bench Pro 69.2% vs 64.7%), and **Grok 4.5** when you want near-frontier quality at lower cost. On the underlying provider APIs Grok is far cheaper on output ($6 vs $25 per million tokens), but note these are external API rates: inside Cursor both models draw from your subscription's included model-request allotment rather than raw per-token billing, so the savings mainly show up on usage-based or API-metered work. Grok's token efficiency, roughly 4.2x fewer output tokens per agentic task, is a genuine edge on long agent runs (it does not affect Cursor's separate Tab autocomplete, which uses its own model).
The catch is that Cursor ties the choice to one editor and a per-seat subscription, and the default model is a manual per-user setting. If your agents also run outside the IDE, or you want coding work routed to Opus and high-volume work routed to Grok automatically across a team, a runtime model selector handles that without the per-seat tax, which is exactly what the setup below does.
---
## So which should you actually use?
- **Choose Grok 4.5 if** cost is the constraint, you're running lots of agentic or automation work, or you're price-sensitive on output-heavy tasks.
- **Choose Claude Opus 4.8 if** you need the top coding score, the largest context window, or long-horizon reasoning where reliability matters more than token cost.
But here's the thing the benchmark charts don't tell you: **this ranking will change again within weeks.** xAI already says a 2-trillion-parameter Grok is due in August 2026 ([news.az](https://news.az/news/musk-says-2t-grok-model-to-launch-next-month)), and Anthropic just shipped Sonnet 5 as a cheaper tier ([The Journal](https://thejournal.com/articles/2026/07/08/anthropic-intros-lower-cost-claude-sonnet-5.aspx)). Whichever you hard-code today, you'll want to reconsider next month.
That's why the smartest teams stop treating this as a permanent choice, and set things up so it isn't one.
---
## The setup that makes the choice reversible: run (or route between) both
If the winner keeps changing, the real advantage isn't picking correctly once, it's being able to **swap models per task without re-plumbing anything.** That's a runtime decision, and it's where [Duet](/) fits.
Duet gives every workspace a persistent cloud server for running AI sessions. Each session keeps its event history, files, and resulting artifacts available to the team. Opus 4.8 is Duet's recommended frontier model, and Grok 4.5 just landed in the model selector as a Balanced option. Every monthly plan includes credits, and the paid reserve covers overage across models. Because the session and its work are decoupled from any single model, you can:
- Point a coding-heavy agent at **Opus 4.8** and a high-volume research or outreach agent at **Grok 4.5**, in the same workspace.
- Switch the model behind an agent when the leaderboard changes (or when one provider has an outage) without rebuilding the workflow. If you're already thinking this way about Claude tiers, the same logic applies across vendors, see our take on [model routing between Opus and Sonnet](/guides/claude-opus-vs-sonnet-model-routing).
- Keep the agent's context, tools, and history intact across sessions, regardless of which model is answering.
This is the honest version of the Duet pitch: it doesn't make Grok or Opus obsolete, and it isn't a third model competing with them. It's the layer that lets you use whichever one is winning this week, and route between them instead of committing. For a "which should you actually use" question, "you don't have to marry one" is the most useful answer there is.
---
## How to run Grok 4.5 or Opus 4.8 in Duet
1. **Start a workspace** with [Duet](https://app.duet.so/sign-in?from=blog-grok-vs-opus). Every workspace gets a persistent cloud server.
2. **Create a session** for the job, such as a coding task or lead-research run.
3. **Assign the model that fits the task.** Opus 4.8 where coding reliability matters, Grok 4.5 where cost and volume do.
4. **Let the session run.** It uses tools, records durable events, and keeps its files and results available to the team.
5. **Swap the model anytime** the benchmarks or pricing shift. The workflow stays put.
---
## FAQ
### Is Grok 4.5 better than Claude Opus 4.8?
It depends on the task. Opus 4.8 leads on coding (SWE-bench Pro 69.2% vs 64.7%) and context window (1M vs 500K tokens), and edges it on overall intelligence (56 vs 54 on the Artificial Analysis Index). Grok 4.5 is far cheaper ($2/$6 vs $5/$25 per million tokens) and more token-efficient. For cost-sensitive, high-volume agent work, Grok wins; for top-tier coding reliability, Opus wins.
### Is Grok 4.5 cheaper than Claude Opus 4.8?
Yes, significantly. Grok 4.5 costs $2 per million input tokens and $6 per million output, versus Opus 4.8's $5 and $25 ([Anthropic](https://www.anthropic.com/news/claude-opus-4-8), [InfoWorld](https://www.infoworld.com/article/4194895/spacexai-launches-grok-4-5-touts-lower-coding-task-costs-than-ai-rivals.html)). Note Grok's rate roughly doubles above a 200K-token context.
### Should I use Grok 4.5 or Opus 4.8 in Cursor?
In Cursor the tradeoff is the same as anywhere: pick Opus 4.8 when coding reliability matters most (SWE-bench Pro 69.2% vs 64.7%) and Grok 4.5 when you want near-frontier quality at lower cost. On the provider APIs Grok is much cheaper on output ($6 vs $25 per million tokens); inside Cursor both run off your subscription's included model requests, so the biggest savings land on usage-based or API-metered work. Because Cursor lets you switch models per request, many developers keep Grok 4.5 as the default and reach for Opus 4.8 on the hardest tasks.
### Which model is best for coding?
Claude Opus 4.8. On SWE-bench Pro it leads 69.2% to Grok 4.5's 64.7% ([Vellum](https://www.vellum.ai/blog/claude-opus-4-8-benchmarks-explained)), and it posts 88.6% on SWE-bench Verified. The gap is modest, so if cost matters, Grok 4.5 is a strong value pick for coding too.
### Can I use both Grok 4.5 and Opus 4.8 without choosing one?
Yes. Platforms like [Duet](https://app.duet.so/sign-in?from=blog-grok-vs-opus) let you run AI sessions on your own server and assign different models to different tasks, so you can route coding work to Opus 4.8 and high-volume work to Grok 4.5, and swap either as models change.
### What's the most reliable way to run AI agents 24/7?
Decouple the agent from any single model. Running agents on a persistent server, [the way Duet runs Claude Code in the cloud](/blog/how-to-run-claude-code-in-the-cloud), means an outage or price change at one provider doesn't break your workflow, you re-point the agent at another model and keep going.
---
## The bottom line
Grok 4.5 and Claude Opus 4.8 are both excellent. Opus leads on coding (SWE-bench Pro 69.2% vs 64.7%) and context, and edges overall intelligence (56 vs 54); Grok wins big on price and token efficiency. Pick Grok for cost, Opus for coding-critical work. But given how fast the frontier is moving, a 2T Grok next month, cheaper Claude tiers this week, the durable move is to set up so you can run and switch between both. [Try Duet free](https://app.duet.so/sign-in?from=blog-grok-vs-opus).
---
Source: https://duet.so/blog/how-duet-builds-and-evals-context-graphs
# How Duet Builds Agent Memory with Context Graphs
*Context engineering is more than a bigger window. A context graph captures the why behind every agent decision — what was weighed, rejected, and overridden. How Duet records and evals it.*
By Duet Team. Published 2026-05-18. 14 min read.
**Quick Summary**
Most agent memory systems store outcomes. Context engineering done right stores the _precedent_ behind every decision — what was considered, rejected, applied, and overridden. Duet's agent memory is built as a context graph in three observation layers, each gated by its own eval. This post walks through how the graph is captured and how we keep the layers honest.
**Questions this page answers**
- What is a context graph?
- What is context engineering, and how is it different from a bigger context window?
- What is agent memory, and what does long-term memory for AI agents actually mean?
- Why isn't a chat transcript or summary enough for an AI agent's memory?
- How does Duet record decision traces from real conversations?
- How do you eval an agent's memory layer without hand-grading it?
- How does this compare to mem0, Letta, LangChain memory, and Claude memory?
## What is context engineering, and what is a context graph?
**Context engineering** is the discipline of shaping what an AI agent actually sees on each turn — not just the prompt, but the retrieved memory, the precedent, the project rules, and the user steers that should override defaults. A bigger context window doesn't solve it. A search index over old transcripts doesn't either. The hard part is deciding _what is worth carrying forward_ and _in what shape_.
A **context graph** is one answer to that question. The framing comes from Foundation Capital's piece [Context Graphs: AI's Trillion-Dollar Opportunity](https://foundationcapital.com/ideas/context-graphs-ais-trillion-dollar-opportunity). Their argument, distilled: the durable value of a knowledge worker's day-to-day isn't the artifacts they ship. It's the **graph of precedents around each decision** — what alternatives were weighed, who approved the exception, which policy was leaned on, which prior call this one built on.
Outcomes get written down. The CRM has the closed-won deal. Git has the merged PR. The doc has the final wording.
The graph almost never does. The discount got approved on a Zoom call. The architecture pivot happened in a Slack thread. The "we don't treat them as legacy" rule came out of one sentence in code review. None of it lands in a system of record, so the next agent — human or AI — re-derives it from scratch and usually picks differently.
For an [AI teammate](/use-cases/small-businesses), that gap is fatal. An agent that only sees outcomes will cheerfully suggest the option you rejected three weeks ago, re-litigate a convention you already settled, or quietly drop the exception you explicitly carved out. It feels forgetful even when its raw recall is perfect, because **recall of outcomes without recall of precedent is not memory of the work — it's memory of the artifact**.
A context graph is the thing that closes that gap. Concretely, for every decision the agent makes or sees you make, it tries to capture six dimensions:
- **Inputs gathered.** Which files, errors, tool results, or prior messages actually shaped the call.
- **Alternatives considered and rejected.** What was tried first and dropped, what was proposed and vetoed.
- **User steers, approvals, overrides.** Your near-verbatim wording when you push back, redirect, or sign off.
- **Convention or policy applied.** Which `AGENTS.md` rule, project guideline, or prior decision was leaned on.
- **Prior precedent.** Which earlier memory row, PR, or session this decision built on.
- **Exception / override flag.** Whether the path taken deviates from the default, and why.
A decision row that records the outcome alone — `"refactored auth into middleware"` — has lost the entire graph. A row that records `"User vetoed the per-route guard approach as overengineered; we extracted a single middleware per the project's 'one auth surface' rule established in the prior auth refactor — exception: keep the legacy `/health` route un-guarded"` is a graph edge a future agent can actually reuse.
## Why bare outcomes aren't enough for agent memory
Most agent memory systems today — whether they call themselves long-term memory, agentic memory, or just "context" — land somewhere on a spectrum between two failure modes.
**Transcript memory.** Keep the whole chat. Look it up by embedding. This is technically lossless but operationally useless: the signal-to-noise ratio is brutal, the relevant precedent is buried inside tool output and small talk, and the agent ends up re-reading the same conversation every turn. Worse, the **graph is implicit** — the agent has to re-derive "you preferred the middleware approach" from the raw exchange every time it's needed.
**Summary memory.** Compress conversations into bullet points. Cheap to retrieve, but the compressor optimizes for outcomes (`"shipped auth middleware on May 14"`) and strips the graph (`"chose middleware over per-route guards after user pushback"`). The agent ends up with a neat little outcome log and no idea why anything is the way it is. Two weeks later it proposes the rejected approach again, and you wonder why it doesn't seem to learn.
A context graph is the third option: deliberately structured around the graph dimensions, with the prompts and the evals both written to keep the graph intact end to end.
## How Duet records agent memory in three layers
Duet builds the context graph in three layers. Each one can independently destroy the graph if it isn't careful, so each one is designed around a single job and gated by its own test.
### Layer 1 — the observer
After every turn, an observer model reads the exchange and writes a small set of observation rows into a memory store living inside the user's workspace. This is where the graph dimensions enter the system.
The observer is not instructed to "summarize this exchange" — that's the failure mode that collapses precedent into outcomes. It's instructed to capture decision traces, with each dimension named and exemplified. The single most important instruction it gets is to preserve **user steers, approvals, and overrides** near-verbatim:
> When the user pushes back, redirects, vetoes, or explicitly approves a path, preserve their wording near-verbatim and treat it as an authority signal. Quotes like _"I think this is overengineered"_, _"we should not treat them as legacy"_, _"do X instead"_, _"go ahead"_ are the equivalent of a VP approving a discount on a Zoom call: not in any system of record until you write it down. These are the highest-signal observations, because they are the precedent that overrides defaults.
The observer also gets two anti-patterns spelled out, because both are easy traps:
1. **Re-readable ground truth is not memory.** If the only thing the exchange produced was "the agent listed a directory and found these files," the row gets dropped — the agent can list the directory again next turn. Memory is reserved for things the agent can't trivially re-discover.
2. **Bare outcomes are invalid.** "X was fixed" isn't a decision trace. A row has to attribute the call to at least one of the six dimensions above, or it isn't worth keeping.
### Layer 2 — the in-session reflector
Within a single session, observations accumulate fast. The in-session reflector periodically compacts them into a rolled-up view that the agent re-loads at the top of each turn. This is the layer that keeps the context graph visible without bloating the prompt.
The compaction step is the second place the graph can die. If the reflector treats user steers as "narrative fluff" and strips them — leaving only the outcome — every downstream layer is starved. The reflector is explicitly told not to: a row that survives compaction has to keep its attribution intact (user steer, convention, prior precedent, observed symptom, or "no precedent — fresh judgement call").
### Layer 3 — the global reflector
Across sessions, the cross-session pool gets periodically atomized into durable, long-term rows. This is the layer that turns a week of work into the institutional memory the agent loads in future sessions.
The constraint here is harder: a row that lands in this layer has to be readable cold, by a future agent that has never seen the original conversation. That means full mini-narratives — trigger → journey → decision → rationale — with concrete identifiers (file paths, PR numbers, dates, version tags) that the future agent can grep for.
A row that survives into this layer is the closest thing the system has to a permanent graph edge. We treat it accordingly.
## How we eval the agent memory layer
Prompts are the easy part. Keeping prompts honest as the system evolves is the hard part. A prompt change that quietly drops "user steers" from the extraction instructions doesn't break any normal test — but it silently amputates the graph from that day forward.
So the memory layer has its own eval suite. The pattern is the same in each one: drive the real layer end-to-end against a live model with a hand-crafted scenario, then grade the output with a domain-specific LLM judge.
### Gating the observer
The observer eval feeds it a short exchange that contains a clear, verbatim user steer — for example, the user pushing back on a file layout and stating _"treat that as the project convention going forward."_ It then asserts that the observation written to memory preserves the steer: phrasing, intent, and precedent flag intact. If a future prompt change makes the observer collapse the exchange into a bare outcome, the eval fails at the judge step. The amputated graph gets caught at the layer where it would otherwise enter the system.
### Gating the reflectors
The in-session reflector and the global reflector share a prompt, so one eval covers both. It runs the reflector against a pool of observations that include user steers, conventions, and exception flags, and grades the rolled-up output against three independent judges:
1. **Narrative shape.** Does each row read as a trigger → journey → decision → rationale mini-story, or has it collapsed back to a bare headline?
2. **Concrete identifiers.** Does each row contain at least one grep-able anchor (file path, PR number, date, version tag) a future agent could actually look up?
3. **User-steer preservation.** Does the row still carry the user's near-verbatim wording, or has it been laundered into generic phrasing?
A reflector that strips any of those gets caught before its output ever reaches a real user.
### Gating the judges
This is the part that's easy to miss. **A judge prompt is just another prompt.** If the judge drifts — too strict, too lenient, fooled by a particular phrasing — every eval downstream of it goes quietly wrong.
So each judge has its own eval with known-answer fixtures: hand-crafted positive cases that must pass, and hand-crafted negative cases that must fail. A judge prompt change has to keep both sets correct before the layer-level evals run. The graders are graded.
## Why this matters for an AI teammate with long-term memory
Build it without the graph and you ship a chatbot with good recall: it remembers what you said, replays your last conversation, finds the file you mentioned. Pleasant. Forgettable. (Memory only starts to matter when the agent is also [always-on across sessions](/blog/how-to-set-up-a-24-7-ai-agent) — otherwise there is nothing to accumulate.)
Build it with the graph and you ship something different in kind. The agent shows up to the next session knowing not just what got done last week, but **why** — which option you rejected, which convention you set, which exception you carved out. It stops re-litigating settled calls. It starts catching its own drift before you do. Over months, it accumulates the kind of institutional memory that's normally locked inside whoever has been at the company longest — the difference between a coding assistant you reset every week and [a coding agent that runs in the cloud and stays with you](/blog/how-to-run-claude-code-in-the-cloud).
That's the bet. The trillion-dollar opportunity in Foundation Capital's framing isn't a model with bigger context — it's a teammate with better precedent. We're [building toward the second](/use-cases).
## Frequently Asked Questions
### What is context engineering?
Context engineering is the practice of designing _what an AI agent sees_ on every turn — the retrieved memory, the project conventions, the user steers, the precedent. It's the layer that decides which past information is worth carrying forward and in what shape. A bigger context window is plumbing; context engineering is the editorial step that decides what flows through it. A context graph is one approach inside that discipline: structured precedent, not raw transcripts.
### What is agent memory, and what does long-term memory for AI agents actually mean?
Agent memory is whatever an AI agent persists across turns or sessions so it doesn't have to re-derive the same context every time. Short-term memory is the current conversation window. Long-term memory for AI agents is the durable layer — the user's conventions, prior decisions, exceptions, and overrides — that survives across sessions. Duet's agent memory is structured as a context graph so what survives isn't just the outcome but the precedent behind it.
### What is the difference between a context graph and a vector memory store?
A vector store indexes raw text by semantic similarity. It can retrieve "things related to auth middleware" but it can't tell you _why_ the middleware approach was chosen over per-route guards, or that you explicitly vetoed the per-route approach as overengineered. A context graph layers a structured decision trace — alternatives, user steers, conventions applied, exceptions — on top of (or instead of) the raw text. Vector recall is necessary but not sufficient.
### How does this compare to mem0, Letta, LangChain memory, or Claude memory?
Most dedicated agent-memory libraries (mem0, Letta, LangChain memory) and product-level memory features (Claude memory, ChatGPT memory) focus on extracting _facts_ from a conversation and recalling them later — things like "the user prefers TypeScript," "the project deploys to Vercel." Useful, but still primarily a fact store. Duet's context graph is built around _decisions and precedent_: not just "the user prefers X," but "the user vetoed Y in favor of X on this date, because of Z, and the exception is W." That graph is what lets an AI teammate stop re-litigating settled calls. The two approaches are complementary — facts are necessary; precedent is what makes the agent feel like it has actually been in the room with you.
### Can I see the observations Duet is storing about my work?
Yes. They live in a local memory store inside your own Duet workspace, and Duet exposes commands to inspect, search, and reflect on them. Nothing leaves your sandbox unless you explicitly share it. The observer and reflector models run through your configured AI gateway, the same as your agent turns.
### How is this different from CLAUDE.md or AGENTS.md project rules?
Project-rule files (`CLAUDE.md`, `AGENTS.md`, similar) are the _policies_ an agent leans on. A context graph is the _case law_ — the actual decisions, exceptions, and overrides that have accumulated on top of those policies. The graph dimensions explicitly include "convention or policy applied" so the case law cites the rule, but the rule alone isn't enough: the value lives in the precedent.
### Won't capturing all this make the agent's prompt enormous?
That's exactly the problem the three layers solve. The observer writes everything. The in-session reflector compacts within a session. The global reflector atomizes across sessions into durable rows that are loaded based on relevance. The agent's actual prompt only sees the slice of the graph that the current turn likely needs — usage-bumped, decayed by freshness, and ranked.
### Where can I read the source?
The memory layer lives in [`duet-agent`](https://github.com/dzhng/duet-agent) under `src/memory/`, and the evals are under `evals/`. The prompts in `src/memory/observational-prompts.ts` are the load-bearing artifact — they're worth reading top to bottom if you're designing your own memory system.
---
Source: https://duet.so/blog/how-to-automate-bookkeeping-financial-reporting-ai
# How to Automate Bookkeeping and Reporting with AI
*Receipts in email, invoices in spreadsheets, tax season panic. Here's how to automate your bookkeeping and financial reporting with AI — for good.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 13 min read.
Somewhere around month three of freelancing, you open a spreadsheet to 'just quickly update the numbers' and realize you haven't touched it since October.
Receipts in your inbox, invoices in a folder, bank statements as PDFs nobody's looked at. Tax season becomes a full week of archaeology.
This is not a you problem. It's a system problem, or more accurately, a lack-of-system problem.
AI bookkeeping tools have made it genuinely painless to automate the whole stack: categorizing transactions, reconciling invoices, generating monthly P&L reports, and flagging anything that needs your attention.
This guide walks through exactly how to set it up, what tools to use, and how to go from 'it's all in my inbox' to a clean financial dashboard that runs itself.
**Quick Summary**
This guide shows how to automate bookkeeping and financial reporting using AI, replacing manual data entry, spreadsheet reconciliation, and report generation with an AI agent that handles it continuously.
**Questions this page answers**
- How to automate bookkeeping with AI
- Best AI tools for small business accounting
- Can AI replace manual bookkeeping?
- How to automate financial reporting with AI
- What bookkeeping tasks can AI automate?
## Freelancer Bookkeeping Problem
Most freelancers and small business owners manage finances in a patchwork system.
Receipts live in email inboxes or camera rolls. Invoices track in spreadsheets. Bank statements arrive as PDFs.
At month-end, you spend 4-6 hours manually categorizing transactions, reconciling accounts, and building reports for your accountant.
This manual process creates three real problems. First, delayed visibility, you don't know your actual P&L until weeks after month close. Second, error accumulation, manual categorization introduces 5-10% error rates on average. Third, tax season panic, scrambling to organize 12 months of data in April. All three are solved by automation.
AI can eliminate all three.
## How AI Categorizes Expenses and Reconciles Accounts
AI bookkeeping works by applying pattern recognition to transaction data.
You train the system once by categorizing 20-30 sample transactions. The AI learns that "Amazon Web Services" is Software, "Shell Station" is Travel, and "Office Depot" is Office Supplies. It then auto-categorizes future transactions with 90%+ accuracy.
Basic categorization workflow:
1. Connect your bank account via Plaid or similar API
1. Set up initial category rules (software, contractors, meals, travel, etc.)
1. Review and confirm AI suggestions for 2-3 weeks
1. Let the system run autonomously once accuracy hits 95%
Reconciliation happens automatically when you connect both your bank feed and invoicing system. The AI matches invoice payments to bank deposits, flags discrepancies, and alerts you to missing payments.
What gets reconciled automatically:
| Transaction Type | AI Task |
| ----------------------- | ----------------------------------------- |
| Invoice payments | Match deposit to invoice, mark as paid |
| Recurring subscriptions | Auto-categorize based on merchant pattern |
| Duplicate charges | Flag for review |
| Refunds/credits | Link to original transaction |
| Foreign currency | Convert and categorize with exchange rate |
Let's get specific. Here's the step-by-step so you can follow along.
## Building Your AI Bookkeeping System
Start with bank data ingestion, then layer on categorization and reporting.
### Connect Your Financial Accounts
Use Plaid, Yodlee, or similar banking APIs to pull transaction data. Most accounting tools (QuickBooks, Xero, Wave) offer native integrations.
Minimum viable setup:
1. Primary business checking account
1. Business credit card
1. PayPal or Stripe if you accept online payments
1. Invoicing system (FreshBooks, Invoice Ninja, etc.)
### Set Up Categorization Rules
Create a rule library that maps merchants to expense categories.
Example rule set:
```plaintext
IF merchant contains "AWS" THEN category = "Software & SaaS"
IF merchant contains "Uber" AND amount < $50 THEN category = "Travel - Local"
IF merchant contains "Hotel" OR "Airbnb" THEN category = "Travel - Lodging"
IF description contains "Refund" THEN flag for review
```
Most AI tools for task automation let you define these as simple if/then logic or train them with labeled examples.
### Generate Monthly P&L Automatically
Schedule a monthly task that compiles categorized transactions into a standard P&L format.
Task structure:
1. Pull all transactions from first to last day of previous month
1. Group by category
1. Calculate totals for revenue and each expense category
1. Generate net income figure
1. Format as PDF or spreadsheet
1. Email to your accountant and yourself
This runs on the 1st of each month without intervention.
## Automating Invoice Creation and Follow-Up
AI can handle the full invoice lifecycle from creation to payment collection.
### Automatic Invoice Generation
When you complete a project or deliver a milestone, the AI generates an invoice based on:
- Client name and billing details (stored in your CRM)
- Project scope and agreed rate (pulled from contract or proposal)
- Hours logged or deliverables completed
- Payment terms (Net 15, Net 30, etc.)
Example automation:
```plaintext
TRIGGER: Task marked complete in project management system
ACTION: Generate invoice with line items from task description
ACTION: Send invoice to client email
ACTION: Add to receivables tracker
```
### Payment Follow-Up Reminders
The AI monitors invoice status and sends reminder emails automatically.
Standard follow-up schedule:
| Days Past Invoice Date | Action |
| ---------------------- | ----------------------------------------- |
| 0 | Send invoice with payment link |
| 7 | Friendly reminder email |
| 14 | Second reminder (one day before due date) |
| 16 | Overdue notice |
| 30 | Final notice before escalation |
Each email is personalized with client name, invoice number, amount due, and payment link. You can review and approve the message templates once, then let them run.
## Processing Receipts and Documents with AI
Document extraction AI reads receipts, invoices, and bank statements to pull structured data.
Upload a restaurant receipt photo. The AI extracts:
- Merchant name
- Date and time
- Total amount
- Tax amount
- Payment method
- Line items (if needed for per diem rules)
This data flows directly into your expense tracker with the correct category applied.
Common document types handled:
- Receipts (photo or PDF)
- Vendor invoices
- Bank statements
- 1099 forms
- Contracts with payment terms
The AI files the original document, extracts key fields, categorizes the transaction, and adds it to your books. No manual typing.
## Tax Preparation Before Tax Season
By running automated bookkeeping all year, tax prep becomes a 30-minute export instead of a week-long project.
### Pre-Tax Season Checklist
January task:
1. Pull full-year transaction report categorized by tax schedule (Schedule C lines)
1. Generate mileage log if you track vehicle expenses
1. Compile all 1099s received
1. Export receipts folder organized by category
1. Create summary P&L for the full year
Your accountant receives a structured package instead of a shoebox of receipts.
### IRS-Ready Categorization
Map your expense categories to IRS Schedule C or corporate tax form line items.
| Your Category | Schedule C Line |
| ---------------------- | ------------------------ |
| Software & SaaS | Line 18 (Office Expense) |
| Contractor Payments | Line 11 (Contract Labor) |
| Advertising | Line 8 (Advertising) |
| Travel - Airfare | Line 24a (Travel) |
| Meals (50% deductible) | Line 24b (Meals) |
The AI applies deductibility rules automatically. Meals get flagged for 50% limitation. Home office percentage gets applied to utilities. Mileage calculates at IRS standard rate.
## Running Bookkeeping on a Cloud Server
Most AI bookkeeping tools run on your laptop, which means they only work when you're online and remember to trigger them.
Moving to a cloud server solves this. Your bookkeeping tasks run on a schedule 24/7, even when your laptop is closed.
What cloud hosting enables:
- Scheduled execution: Tasks run at 2 AM on the 1st of every month automatically
- Always-on monitoring: Invoice reminders send on time, even during vacation
- Secure credential storage: Bank API tokens and passwords stay on the server, not your laptop
- Persistent state: The AI remembers categorization patterns and reconciliation history
This is where Duet becomes relevant. Duet is a cloud-based AI agent platform that runs automation workflows on a persistent server. You set up your bookkeeping tasks once, they run continuously without local intervention.
Example Duet workflow for monthly close:
1. Connect to bank API and pull last 30 days of transactions
1. Run categorization AI on new transactions
1. Generate P&L report in PDF format
1. Extract receipts from email inbox and attach to matching transactions
1. Email full package to accountant
This runs as a scheduled task every month. You review the output, make corrections if needed, and approve. Takes 10 minutes instead of 4 hours.
For more on setting up persistent AI agents, see How to Set Up a 24/7 AI Agent.
## Freelance Consultant
Here's a complete automation stack for a freelance consultant billing $150K/year.
### Tools Used
- Banking API: Plaid (connects to Chase business checking)
- Invoicing: Invoice Ninja (open source, self-hosted)
- Receipt storage: Dropbox folder with OCR
- Categorization AI: Custom script using OpenAI API for pattern matching
- Reporting: Python script generates P&L from categorized transactions
- Hosting: Duet for scheduled execution
### Monthly Process Before Automation
1. Download bank CSV (10 minutes)
1. Manually categorize 80-120 transactions (90 minutes)
1. Match invoice payments to deposits (30 minutes)
1. Build P&L spreadsheet (20 minutes)
1. Upload receipts and rename files (15 minutes)
1. Email package to accountant (5 minutes)
Total time: 2 hours 50 minutes per month
### Monthly Process After Automation
1. Review AI-categorized transactions and fix errors (10 minutes)
1. Approve and send P&L report (2 minutes)
Total time: 12 minutes per month
Time saved: 2 hours 38 minutes per month = 31.5 hours per year
At a billing rate of $150/hour, that's $4,725 in recovered billable time annually.
## Common Pitfalls and How to Avoid Them
### Over-Automating Too Soon
Don't automate categorization until you have 90%+ accuracy. Review AI suggestions manually for the first month. Correct errors immediately so the system learns.
Safe automation progression:
- Week 1-2: Review every transaction, confirm or correct category
- Week 3-4: Spot-check 25% of transactions randomly
- Month 2+: Review only flagged transactions and monthly totals
### Ignoring Reconciliation Discrepancies
When the AI flags a discrepancy between invoice and deposit, investigate immediately.
Common causes:
- Payment processor fees deducted before deposit
- Client paid partial amount
- Bank delayed processing
- Duplicate invoice sent by mistake
Set up alerts for any mismatch over $50 so you catch issues within 24 hours.
### Not Backing Up Financial Data
Cloud-based systems should export raw data weekly to your own storage.
Backup checklist:
- Transaction CSV (all categorized data)
- Receipt image files
- Invoice PDFs
- P&L reports archive
Store in a separate location from your automation server. If your AI tool shuts down or corrupts data, you have a complete paper trail.
## Advanced Multi-Entity and Client Billing
If you run multiple businesses or bill clients with different structures, segment your automation.
### Multi-Entity Setup
Create separate workflows for each legal entity (LLC, S-Corp, etc.).
Each entity gets:
- Dedicated bank connection
- Separate categorization rules
- Individual P&L output
- Isolated receipt storage
Tag transactions with entity ID so you can run consolidated reports across all entities when needed.
### Client-Specific Billing Rules
Some clients require custom invoice formats or billing cycles.
Example rules:
- Client A: Weekly invoices, itemized hours, Net 15 terms
- Client B: Monthly invoices, flat project rate, Net 30 terms
- Client C: Milestone-based invoices, 50% upfront, 50% on delivery
The AI stores these rules per client and applies them automatically when generating invoices. You can override individual invoices if needed, but 95% run without changes.
## Measuring ROI on Bookkeeping Automation
Track time saved and error reduction to quantify the value.
Metrics to monitor:
| Metric | Before Automation | After Automation |
| --------------------------------- | ----------------- | ---------------- |
| Hours per month on bookkeeping | 8-12 hours | 0.5-1 hour |
| Transaction categorization errors | 8-15 per month | 1-3 per month |
| Overdue invoices (30+ days) | 15-20% | 3-5% |
| Days to close monthly books | 10-14 days | 1-2 days |
| Accountant prep fees | $300-500/month | $150-200/month |
Most freelancers see full payback within 2-3 months after setup costs.
## Frequently Asked Questions
### Can AI bookkeeping handle cash transactions and receipts without bank feeds?
Yes. Upload receipt photos or PDFs to your automation system and the AI will extract merchant, date, amount, and category using OCR and document extraction. You manually record cash transactions once by logging them in a spreadsheet or app, then the AI categorizes and includes them in monthly reports. For businesses with high cash volume, use a daily receipt upload workflow instead of waiting until month-end.
### Is AI bookkeeping compliant with IRS requirements for record retention?
AI bookkeeping systems meet IRS requirements if you retain original transaction records and receipts for the required period (generally 3-7 years depending on transaction type). The AI should store original bank statements, receipt images, and invoice PDFs in addition to categorized transaction logs. Ensure your system can export a complete audit trail showing original source documents linked to categorized entries.
### How much does it cost to automate bookkeeping for a small business?
Expect $50-200/month in software costs (banking API, document extraction AI, cloud hosting) plus 10-20 hours of initial setup time. If you hire a developer to build custom workflows, add $1,000-3,000 for setup. Most freelancers and small businesses break even within 2-3 months from time saved and reduced accountant fees, then save $200-400/month ongoing.
### Can AI automatically file sales tax returns and payroll taxes?
AI can calculate amounts owed and prepare filing documents, but most jurisdictions require human review and electronic signature before submission. The AI generates completed tax forms with calculated figures, you review for accuracy, then electronically file through the appropriate portal. Payroll tax automation is more restricted and often requires certified payroll software with specific government integrations.
### What happens if the AI categorizes a transaction incorrectly?
Review your monthly categorization report and correct any errors before finalizing. When you reclassify a transaction, the AI learns from the correction and improves future accuracy. Most systems show a confidence score per transaction so you can prioritize reviewing low-confidence items. After 2-3 months of corrections, accuracy typically exceeds 95% and you only need to review flagged transactions.
### How to handle foreign currency transactions and international clients?
Connect your bank API to pull transactions with original currency and exchange rate data. The AI categorizes based on merchant name regardless of currency, then converts amounts to your reporting currency (USD, EUR, etc.) using the exchange rate from transaction date. For invoicing international clients, specify their currency in the client profile and the AI generates invoices in that currency while recording revenue in your base currency.
### Is bookkeeping automation secure enough for sensitive financial data?
Use systems with bank-level encryption (AES-256) for data at rest and TLS for data in transit. Banking APIs like Plaid use OAuth and never expose your actual bank credentials to third parties. Host automation workflows on secure cloud servers with credential management systems rather than storing passwords in scripts. Enable two-factor authentication on all financial accounts and limit API access to read-only when possible.
---
Source: https://duet.so/blog/how-to-automate-competitive-intelligence-startup
# How to Automate Competitive Intelligence for Your Startup
*Your competitors are moving fast. Automate your competitive intelligence so you're never caught off guard again.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 15 min read.
Most startups do competitive research the same way: someone googles the main competitors once a quarter, updates a slide deck, and calls it done. Meanwhile, your competitors are shipping new features, changing their pricing, running new ad angles, and hiring into functions that signal exactly where they're going next — and you're finding out about it months later.
Automated competitive intelligence changes that. Instead of a quarterly snapshot, you get a continuous feed of the signals that actually matter — product changes, messaging shifts, hiring patterns, ad creative, customer sentiment. This guide covers how to build that system using AI, what signals to prioritise, and how to turn competitive data into decisions rather than just a longer slide deck.
**Quick Summary**
This guide covers how to automate competitive intelligence for your startup using AI — continuously monitoring competitor moves, pricing changes, content updates, and market signals so you always know what's happening without manual research.
**Questions this page answers**
- How to automate competitive intelligence with AI
- Best AI tools for startup competitive analysis
- How to monitor competitors automatically with AI
- Can AI replace manual competitive research?
- How to set up an AI competitive intelligence system?
## Why Manual Competitor Research Fails Startups
You check a competitor's pricing page once. They change it three weeks later. You miss the signal until a prospect mentions it in a call.
Manual competitive research has three fatal flaws:
- Inconsistent coverage — You remember to check competitors when you have time, which means you don't
- Snapshot bias — You see what's live today, not what changed or when
- No pattern detection — Humans can't spot trends across 12 data points collected monthly
Startups that track competitors systematically make faster decisions. When a competitor drops prices, launches a feature, or shifts messaging, automated systems catch it within 24 hours.
The gap between reactive and proactive competitive intelligence is the difference between responding to market changes and anticipating them.
## What Competitor Data Actually Matters
Not everything competitors do deserves your attention. Focus on signals that affect your positioning or customers' buying decisions.
Track these five areas:
- Pricing changes — New tiers, discounts, packaging shifts
- Feature launches — Product updates, new capabilities, deprecated features
- Hiring patterns — Engineering roles signal product direction, sales hires signal expansion
- Content strategy — Blog topics, SEO keywords, messaging changes
- Social presence — Engagement rates, campaign themes, audience growth
Monitor 3-5 direct competitors and 2-3 adjacent players. More than eight creates noise without insight.
For each competitor, identify 4-6 specific URLs to track: homepage, pricing page, features page, about/team page, blog index, and careers page.
## How to Set Up Automated Competitor Website Scraping
Automated scraping means scheduled jobs that fetch competitor pages, extract relevant content, and store it for comparison.
Step 1: Choose your scraping method
Three approaches work for most startups:
- Firecrawl — Handles JavaScript rendering, returns clean markdown, supports scheduled runs
- Playwright scripts — Full browser control for complex sites
- Simple HTTP requests — Works for static HTML sites
Firecrawl works for 80% of competitor sites and requires less maintenance than custom scripts.
Step 2: Set up scheduled scraping
Create a scraper that runs daily at the same time:
```javascript
// Daily competitor scrape job
schedule('0 9 * * *', async () => {
const competitors = [
{
name: 'CompetitorA',
urls: ['https://competitora.com/pricing', 'https://competitora.com/features'],
},
{
name: 'CompetitorB',
urls: ['https://competitorb.com/pricing', 'https://competitorb.com/solutions'],
},
]
for (const competitor of competitors) {
for (const url of competitor.urls) {
const content = await scrapeUrl(url)
await saveSnapshot(competitor.name, url, content, new Date())
}
}
})
```
Step 3: Store snapshots with timestamps
Save each scrape result with metadata:
- Competitor name
- URL
- Content hash
- Full content
- Timestamp
- Previous hash for comparison
This structure enables change detection and historical analysis.
Step 4: Handle rate limiting and failures
Add delays between requests (2-3 seconds), retry logic for timeouts, and alerts when scrapes fail for 3+ consecutive days.
Most competitor sites won't block reasonable scraping (once daily), but use residential proxies if you encounter issues.
## Building a Change Detection System
Raw scrapes become useful when you detect what changed. Change detection compares current content against previous snapshots and flags differences.
Step 1: Implement content comparison
Hash each page's content and compare against the previous hash:
```javascript
const currentHash = hashContent(newContent)
const previousHash = await getPreviousHash(competitor, url)
if (currentHash !== previousHash) {
const diff = generateDiff(previousContent, newContent)
await logChange(competitor, url, diff, timestamp)
}
```
Step 2: Filter out noise
Not every change matters. Filter out:
- Copyright year updates
- Session IDs and dynamic tokens
- Ad content rotations
- Minor wording tweaks (less than 3% of content)
Focus on structural changes, new sections, removed content, and pricing/feature modifications.
Step 3: Categorize changes automatically
Use pattern matching or AI to classify changes:
- Pricing — Dollar amounts, "per month", plan names
- Features — "New", "Now available", feature list additions
- Content — New blog posts, case studies, resources
- Team — New job listings, team page updates
Categorization helps you scan changes quickly without reading every diff.
Step 4: Set up change alerts
Send immediate notifications for high-priority changes:
- Pricing increases or decreases over 10%
- New product launches or major features
- Changes to competitive positioning statements
Weekly digests work for lower-priority changes like blog posts or minor copy updates.
## Turning Raw Data Into Strategy Insights
Scraped data and change logs are inputs, not outputs. The value comes from analysis that answers strategic questions.
Ask these questions systematically:
Automate insight generation with AI
Feed change logs to an AI model with this prompt structure:
```plaintext
Analyze these competitor changes from the past week:
[Change logs]
Answer:
1. What strategic shifts do these changes indicate?
2. Which changes pose threats to our positioning?
3. What opportunities do these changes create for us?
4. What should we monitor more closely next week?
Format as bullet points, focus on actionable insights.
```
| Action | Frequency | Time Required |
| ----------------------------- | --------- | ----------------- |
| Automated scrape runs | Daily | 0 min (automated) |
| AI digest review | Weekly | 10 min |
| Deep-dive competitor analysis | Monthly | 30 min |
| Strategy update | Quarterly | 2 hours |
Run this analysis weekly and compile results into a standing competitive intelligence brief.
Create competitor movement patterns
Track changes over time to identify patterns:
- Monthly product cadence — Do they ship new features the first week of each month?
- Seasonal pricing — Do they run promotions in Q4?
- Content themes — Are they shifting from technical to business content?
Patterns reveal strategy and help you anticipate moves before they happen.
## How to Build a Self-Updating Competitive Dashboard
Dashboards turn data into visibility. A good competitive intelligence dashboard answers questions at a glance.
Step 1: Design around key questions
Structure your dashboard around decisions, not data:
- Top section — Changes flagged this week, ordered by priority
- Competitor overview — Grid showing last change date per area (pricing, features, content)
- Trend charts — Pricing over time, feature release velocity, content volume
- Alert feed — Chronological log of detected changes
Avoid vanity metrics. Every chart should support a decision.
Step 2: Choose your dashboard platform
Three approaches:
- Custom web app — Full control, requires development time
- Notion or Airtable — Updates via API, collaborative, limited visualization
- Business intelligence tools — Tableau, Metabase, or similar if you have data infrastructure
For early-stage startups, a simple web app with charts served from a JSON file works well.
Step 3: Automate data updates
Your scraping and analysis jobs should write directly to the dashboard's data source:
```javascript
// After analysis completes
await updateDashboard({
timestamp: new Date(),
changes: detectedChanges,
insights: generatedInsights,
alertLevel: calculateAlertLevel(detectedChanges),
})
```
Step 4: Add historical comparison
Show current state alongside previous periods:
- Pricing this month vs. three months ago
- Feature count change over six months
- Content publishing frequency by quarter
Context turns absolute numbers into meaningful signals.
Step 5: Make it accessible
Share dashboard access with product, marketing, and sales teams. Different roles care about different signals:
- Product — Feature launches, roadmap hints
- Marketing — Messaging shifts, content strategy, SEO
- Sales — Pricing, new capabilities, customer segments
Weekly dashboard reviews in team meetings keep competitive intelligence actionable.
## Setting Up Automated Weekly Intelligence Reports
Weekly reports synthesize dashboard data into narrative format that stakeholders can consume in 5-10 minutes.
Report structure:
1. Executive summary (3-4 sentences): Most important developments this week
1. Competitor highlights (per competitor): Changes detected, strategic implications
1. Market movements: Industry news, funding, partnerships affecting competitive landscape
1. Recommended actions: 2-3 specific things your team should do based on intelligence
1. Next week watch list: What to monitor closely
Automate report generation:
Use AI to compile weekly reports from change logs and analysis:
```javascript
// Weekly report job
schedule('0 8 * * MON', async () => {
const weekChanges = await getChangesLastWeek()
const insights = await analyzeChanges(weekChanges)
const marketNews = await getIndustryNews()
const report = await generateReport({
changes: weekChanges,
insights: insights,
news: marketNews,
previousWeekReport: await getPreviousReport(),
})
await sendReport(report, recipients)
await saveReportArchive(report)
})
```
Include visual elements:
- Screenshot comparisons showing before/after of pricing or feature pages
- Charts showing pricing trends or feature velocity
- Tables comparing your offering to updated competitor capabilities
Visual evidence makes reports scannable and credible.
## Using Duet for Fully Automated Competitive Intelligence
Duet's persistent server environment solves the infrastructure problem that stops most startups from automating competitive intelligence.
Instead of cobbling together separate services for scraping, storage, analysis, and reporting, you can build the entire system in one place. Set up Firecrawl to scrape competitor sites on a daily cron schedule, store snapshots in JSON files on the persistent server, use Claude to analyze changes and generate insights, and compile everything into a weekly report — all running automatically without manual intervention.
The workflow looks like this: Morning scraper runs through your competitor list, saves content to dated folders, compares against previous day's snapshots, flags changes above your threshold, feeds flagged changes to Claude for strategic analysis, and writes the output to a dashboard JSON file. On Monday mornings, a separate job pulls the week's changes, generates a formatted report, and sends it to your team channel or email.
Because Duet provides both the compute environment and AI context in one tool, you skip the integration complexity of connecting scrapers to databases to analysis APIs to notification systems. The entire competitive intelligence pipeline lives in a single codebase you can iterate on. Learn more at duet.so.
## Common Pitfalls in Competitive Intelligence Automation
Tracking too many competitors
More than 8-10 competitors creates overwhelming data volume. You'll stop reviewing reports when every week brings 40+ flagged changes.
Solution: Track 3-5 direct competitors closely, monitor 2-3 adjacent players at lower frequency.
Ignoring legal and ethical boundaries
Scraping public websites is generally legal, but accessing gated content, bypassing paywalls, or violating terms of service creates risk.
Solution: Only scrape publicly accessible pages, respect robots.txt, keep scraping frequency reasonable (once daily maximum).
Building brittle scrapers
Hardcoded CSS selectors break when competitors redesign sites. Your system fails silently until you notice stale data.
Solution: Use content-based extraction (Firecrawl, Diffbot) instead of structure-based scraping when possible. Add monitoring that alerts when scrapers return empty or malformed data.
Collecting data without analysis
Accumulating competitor snapshots doesn't create value. Unused data is wasted effort.
Solution: Build analysis and reporting before scaling scraping. Start with weekly manual review of data, then automate the analysis patterns you use most.
Alert fatigue
Flagging every competitor change trains your team to ignore notifications.
Solution: Set priority levels. Only send immediate alerts for major pricing or product changes. Batch minor changes into weekly digests.
## How to Measure If Your System Works
Track these metrics to validate your competitive intelligence automation:
Coverage metrics:
- Scrape success rate (target: 95%+)
- Competitors monitored vs. competitors in market
- Key pages tracked per competitor (target: 4-6)
Detection metrics:
- Average time from competitor change to detection (target: < 24 hours)
- False positive rate on change detection (target: < 15%)
- Changes flagged vs. changes that led to action
Impact metrics:
- Product decisions informed by competitive intelligence per quarter
- Sales objection handlers updated based on competitor changes
- Time saved vs. manual competitor research (compare quarterly)
Good competitive intelligence automation should surface 2-4 actionable insights per month that influence product, marketing, or sales decisions.
If your system runs for three months without changing any decisions, you're tracking the wrong data or not analyzing it effectively.
## Advanced: Adding Market Intelligence Beyond Competitors
Competitive intelligence becomes market intelligence when you track adjacent signals.
Add these data sources:
- Industry news APIs — Track product launches, funding, and partnerships (NewsAPI, AlphaVantage)
- Job listing aggregators — Monitor hiring patterns across competitors (Adzuna, GitHub Jobs)
- Technology tracking — See what tools competitors adopt (BuiltWith, Wappalyzer)
- Social listening — Track brand mentions and sentiment (structured Twitter/LinkedIn scraping)
- Review site monitoring — Watch G2, Capterra, and Trustpilot for competitive reviews
Combine these streams in your weekly intelligence report for context beyond what competitors say about themselves.
Build predictive indicators:
Some data points predict future moves:
- Engineering hiring surge → Product launch in 3-6 months
- Marketing manager hire → Messaging refresh in 2-3 months
- Pricing page A/B testing → Pricing change in 4-8 weeks
Track leading indicators to anticipate competitive moves before they happen.
## Frequently Asked Questions
### How much does it cost to automate competitive intelligence?
Budget $50-200 per month depending on competitor count and scraping frequency. Firecrawl costs $29-99/month for 500-5000 scrapes. Hosting the analysis system on a persistent server adds $10-30/month. AI API calls for weekly analysis cost $5-20/month. One-time development takes 8-15 hours if you build it yourself. The alternative, hiring an analyst to manually track competitors, costs $3000-6000 monthly for fractional work or $60,000+ for full-time.
### How do I know if competitors will block my scrapers?
Most B2B SaaS companies don't block reasonable scraping of public pages. Signs you might encounter resistance: sites with aggressive bot protection (Cloudflare with challenge pages), frequent CAPTCHA prompts, or explicit anti-scraping terms of service. Mitigate risk by keeping scraping frequency low (once daily maximum), using residential proxies if needed, respecting robots.txt directives, and only accessing publicly available content. If a critical competitor blocks scraping, fall back to manual monthly checks or use third-party data providers like Datanyze or Owler.
### Should I track what competitors say or what they do?
Both, with priority on actions over statements. What competitors do, ship features, change pricing, hire talent, publish content, reveals strategy more accurately than what they say in marketing. Track doing through product changes and hiring. Track saying through messaging and positioning. The gap between the two often signals future direction: if they message enterprise focus but hire SMB sales reps, the real strategy is SMB expansion.
### How often should I review competitive intelligence reports?
Weekly reviews for 30 minutes keep intelligence actionable without consuming excessive time. Monthly deep dives (2-3 hours) identify longer-term patterns and strategy shifts. Daily monitoring creates noise and alert fatigue. Quarterly competitive reviews with cross-functional teams translate intelligence into roadmap and GTM decisions. The weekly cadence catches time-sensitive changes while quarterly reviews handle strategic response.
### What if my competitors change their sites too frequently?
High change frequency is signal, not noise. Competitors that update pricing or features weekly are experimenting aggressively, track both the changes and the pattern of changes. Filter out trivial updates (copyright years, minor copy edits, ad content) while flagging substantive changes. If legitimate changes exceed your review capacity (10+ meaningful changes per week), narrow tracking to highest-priority pages only: pricing and core product pages. Ignore blog and resources sections until capacity allows.
### Can I automate competitive intelligence for non-SaaS competitors?
Yes, with adjusted methods. E-commerce competitors need product catalog monitoring and pricing scraping. Service businesses require blog and case study tracking plus review site monitoring. Physical product companies need availability tracking and retail channel monitoring. The core approach, scheduled scraping, change detection, automated analysis, works across industries. Adapt the data points tracked to your market: product availability instead of feature launches, retail pricing instead of SaaS tiers, distribution partnerships instead of integrations.
### How do I handle competitors in private beta or with gated content?
Track only publicly accessible information and accept limited visibility. Monitor job listings, press releases, and social media for indirect signals. Request product demos using a real identity and take notes, but don't record or share demo content externally. Some competitive intelligence professionals create test accounts with clear identities, but this creates legal and ethical gray areas. Focus your system on the 3-5 competitors with public information while manually monitoring private-beta competitors quarterly through public signals only.
---
Source: https://duet.so/blog/how-to-automate-content-creation-one-person-business
# How to Automate Content Creation as a One-Person Business
*15 hours a week on content. Or 3. AI-powered content automation for one-person businesses — blog posts, social, newsletter, all of it.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 16 min read.
The content math for solopreneurs is brutal. Daily LinkedIn posts, weekly blog, biweekly newsletter, occasional Twitter threads — you need to be everywhere, and you also need to actually run your business. Most people either burn out trying to do it all or quietly give up and post once a month.
AI doesn't fix the strategy part. You still need a point of view, an audience, and something worth saying. But it can take the execution from 15+ hours a week down to 3-4. The research, the first drafts, the reformatting for different platforms, the scheduling, all of that can be automated.
This is the content automation system a one-person business can actually sustain long-term.
AI content creation tools let solopreneurs build automated publishing pipelines that generate blog posts, social media content, images, and video without manual work. You can turn a single blog post into 10 social posts, 3 images, and video clips while maintaining your brand voice through prompt templates.
**Quick Summary**
This guide shows how a one-person business can automate content creation end-to-end using AI, from ideation and drafting to scheduling and publishing, building a content system that runs itself.
**Questions this page answers**
- How to automate content creation as a solopreneur
- Best AI tools for content creation automation
- How to build an AI content system for a one-person business
- Can AI run a full content calendar automatically?
- How to automate blog and social media content with AI
## The Solopreneur Content Problem
You need to post daily on LinkedIn, write weekly blog articles, send biweekly newsletters, and show up on Twitter. Meanwhile, you're also doing sales calls, building your product, and handling support.
Content marketing works. But publishing 5 times per week takes 15-20 hours you don't have.
The math doesn't work as a blog post takes 4 hours (research, writing, editing, images), 10 social posts take another 2, the newsletter another 1.5 hours. That's nearly 8 hours a week just on content, before you've done any actual client work. Something always gets cut, and it's usually the content.
That's 10.5 hours per week just for content. As a one-person business, you have maybe 3 hours available.
## What AI Content Automation Actually Means
AI content automation means setting up workflows that run without you. Not just "AI writes faster." That's still manual work.
True automation means:
1. AI monitors trending topics in your niche daily
1. AI drafts content based on those topics
1. AI generates images, video clips, and audio versions
1. AI schedules and publishes across platforms
1. System runs on a schedule, even when you're offline
The difference: manual AI use saves time. Automated AI workflows give you leverage.
## The Core Content Multiplication Workflow
Start with one pillar piece. Use AI to create 10+ derivative assets.
### **Research trending topics**
Use AI to scan:
- Top posts in your industry subreddit (last 7 days)
- LinkedIn trending topics in your niche
- Google Trends data for your keywords
- Competitor blog traffic (via SEMrush or Ahrefs)
Prompt: "Find the 5 most discussed topics about [your niche] in the last week. Include post engagement numbers and why each topic is trending."
### **Generate the pillar article**
Use your research to write a 1,500-word blog post. Include:
- Data points from your research
- Your perspective or framework
- Actionable steps
- Real examples
Prompt: "Write a 1,500-word blog post about [topic]. Use this research: [paste findings]. Include 3 specific examples, 2 data points, and a 5-step framework. Write in [your voice description]."
### **Extract social posts**
Pull quotes, stats, and insights from the article. Each becomes a standalone post.
Prompt: "Extract 10 social media posts from this article. 5 for LinkedIn (150-200 words), 5 for Twitter (under 280 characters). Each must work standalone. Include the hook in the first sentence."
### **Generate images**
Create visuals for each platform:
- Blog header image
- Social media graphics (quote cards, stats visualizations)
- Thumbnail for video version
Use AI image generators like Midjourney, DALL-E 3, or Stable Diffusion.
Prompt: "Create a professional graphic showing [key stat from article]. Style: minimalist, brand colors #27C08D and #FBFDFC, sans-serif typography. 1200x630px for social sharing."
### **Create video/audio versions**
Turn your article into:
- 60-second video summary (script + auto-generated visuals)
- Audio version for podcast feeds
- YouTube video with chapters
Use text-to-speech for narration, auto-generate b-roll from stock footage or AI video tools.
Output from one article:
- 1 blog post (1,500 words)
- 10 social posts (LinkedIn + Twitter)
- 3 images (header + 2 social graphics)
- 1 video clip (60 seconds)
- 1 audio file (podcast version)
- Total manual time: 30 minutes to review and approve
For more on automating marketing workflows, see how to scale a marketing agency without hiring.
## How to Maintain Your Authentic Voice While Using AI
AI sounds generic by default. Your voice is your competitive advantage. Following is how you can program it in.
### Create a Voice Guideline Document
Write down your brand voice rules:
| Element | Your Rule | Example |
| ----------------- | ------------------------------------- | ------------------------------------ |
| Tone | Direct, no fluff | "Use X, not Y" vs "Consider using X" |
| Sentence length | Under 20 words | Short sentences. One point each. |
| Forbidden phrases | "Leverage", "synergy", "game-changer" | Ban corporate speak |
| Perspective | Second person "you" | Talk to reader directly |
| Complexity | 8th grade reading level | Avoid jargon |
### Build Prompt Templates
Create reusable prompts that inject your voice:
Blog post template:
```plaintext
Write a [word count] blog post about [topic].
Voice rules:
- Tone: [your tone]
- Sentence length: [your preference]
- Never use: [banned phrases]
- Always include: [required elements]
Structure:
[Your preferred structure]
Research:
[Paste your research]
```
Social post template:
```plaintext
Write a LinkedIn post about [angle from article].
Rules:
- First sentence must hook
- No hashtags
- Include one specific number
- Under 200 words
- End with a question
Content: [paste relevant section]
```
### Review and Edit with Your Filter
AI gives you 80%. You add the 20% that makes it yours:
1. Replace generic examples with your specific stories
1. Add your hot takes or controversial angles
1. Insert your frameworks or terminology
1. Cut the fluff sentences
1. Add subheadings that sound like you
Editing 1,500 AI words takes 15 minutes. Writing from scratch takes 4 hours.
For more on using AI for business writing, check out how to use AI to research and write sales emails.
## Setting Up an Always-On Content Pipeline
Manual AI work still requires you. Automated pipelines run without you.
### The Architecture
Daily research agent:
- Runs every morning at 8am
- Scans trending topics in your niche
- Saves top 5 to a file with engagement data
Weekly content generator:
- Runs every Sunday at 6am
- Picks the top trending topic
- Generates: blog post, 10 social posts, 3 images
- Saves drafts to review folder
Scheduler agent:
- Runs Monday at 9am
- Takes approved content from review folder
- Schedules across platforms (LinkedIn, Twitter, blog)
- Publishes throughout the week
The problem: your laptop needs to be on and connected. Most automation tools run locally.
This is where cloud-hosted AI agents come in. You need a server that stays online 24/7, runs your AI workflows on schedule, and stores your content pipeline.
Platforms like Duet provide cloud sandboxes where you can deploy AI agents that run on cron schedules. Upload your prompt templates and voice guidelines. Set up workflows that chain together research, writing, image generation, and publishing. The agent runs whether you're online or not.
What this unlocks:
- Cron scheduling: your content agent runs every Sunday morning, no laptop required
- Persistent memory: your brand guidelines and voice rules live in the agent's context
- Tool integration: connect to publishing APIs, analytics, image generators
- App hosting: build a simple review dashboard to approve content before it publishes
Example workflow running on a cloud server:
```plaintext
Sunday 6am: Research agent finds trending topics
Sunday 7am: Writing agent drafts blog post + social posts
Sunday 8am: Image agent generates graphics
Monday 9am: Scheduler publishes approved content across platforms
```
You review on Sunday evening. Approve the batch. Content publishes all week while you do client work.
### Platform Integrations You Need
Research tools:
- Reddit API (trending posts)
- Google Trends API (search volume)
- Twitter API (popular tweets)
Content generation:
- Claude or GPT-4 (writing)
- Midjourney or DALL-E (images)
- ElevenLabs (voice for audio versions)
Publishing platforms:
- WordPress or Ghost (blog)
- Buffer or Hootsuite (social scheduling)
- ConvertKit or Beehiiv (newsletter)
Analytics:
- Google Analytics (blog traffic)
- Platform native analytics (engagement tracking)
Connect these via APIs. Your AI agent calls them in sequence.
For more on building automated systems, see how to set up a 24/7 AI agent.
## Example: One Blog Post to 10 Social Posts in 5 Minutes
Your starting point can be straightforward.
Blog post: "5 Ways to Automate Your Sales Outreach"
Prompt to AI:
```plaintext
Extract 10 social media posts from this article:
[paste article]
Requirements:
- 5 LinkedIn posts (150-200 words each)
- 5 Twitter threads (3-5 tweets each)
- Each post must be self-contained
- Include specific numbers from the article
- First sentence must hook the reader
- End each with a question or CTA
```
Output in 2 minutes:
LinkedIn Post 1:
> I spent 4 hours a day on cold emails. Now I spend 20 minutes.
>
> The difference? I automated the research, personalization, and follow-ups.
>
> Here's the system:
>
> 1. AI scrapes LinkedIn for prospects matching my ICP
> 2. AI writes personalized first lines based on recent activity
> 3. AI schedules 50 emails per day across 10 days
> 4. AI sends follow-ups to non-responders after 5 days
>
> Result: 200 emails sent, 40 replies, 8 calls booked. All while I focused on closing deals.
>
> What's the most time-consuming part of your outreach?
Twitter Thread 1:
> I automated my entire sales outreach pipeline.
>
> Result: 8 calls booked per week with 20 minutes of work.
>
> Here's the 5-step system:
>
> 1/5
(Thread continues with each step from the article)
Then generate images:
Prompt: "Create a quote card with this text: '4 hours 20 minutes: What happens when you automate sales outreach.' Style: clean, minimal, brand color #27C08D, 1080x1080px."
Total time:
- AI extraction: 2 minutes
- Image generation: 1 minute
- Review and tweaks: 2 minutes
- Total: 5 minutes
You turned 1 blog post into 10 ready-to-publish social posts plus graphics.
## The Content Repurposing Matrix
One piece of pillar content can become 20+ assets.
| Original Asset | Derivative Assets | Time to Generate |
| -------------------------------- | ----------------------------------- | ---------------- |
| 1,500-word blog post | 10 social posts (LinkedIn, Twitter) | 5 min |
| 3 quote cards | 3 min | |
| 1 carousel post (10 slides) | 5 min | |
| 1 email newsletter | 3 min | |
| 1 video script (60 sec) | 3 min | |
| 1 podcast script (5 min episode) | 3 min | |
| 5 Instagram story frames | 4 min | |
| 1 infographic | 5 min | |
| Total | 22 assets | 31 minutes |
Without AI: creating these manually takes 12+ hours.
With AI: 31 minutes of review time.
## Common Mistakes Solopreneurs Make with AI Content
**Publishing AI content unedited**
AI writes at 80% quality. The last 20% is your voice, your examples, your hot takes. Always edit before publishing.
**Using the same prompt for everything**
Different platforms need different formats. LinkedIn wants longer, story-driven posts. Twitter wants punchy threads. Customize your prompts per platform.
**No brand consistency**
Create a voice guide document. Reference it in every prompt. Without this, your content sounds like 10 different people wrote it.
**Ignoring analytics**
Track what performs. Feed high-performing topics back into your content agent. Let AI analyze your top posts and generate similar content.
**Over-automating**
Don't automate the publishing decision. Review before content goes live. Automation handles generation. You handle quality control.
## Building Your First Automated Content Pipeline
### Set up research automation
Week 1 should be followed with:
1. Choose your research sources (Reddit, Twitter, Google Trends)
1. Write a prompt that scans for trending topics
1. Test it manually, refine the output
1. Set it to run daily, save results to a file
### Automate content drafting
Week 2 you should:
1. Pick your top trending topic from last week
1. Write a prompt that generates a blog post + social posts
1. Test with 3 different topics, refine the prompt
1. Create templates for blog, LinkedIn, Twitter, newsletter
### Add image generation
Week 3 you should be able to:
1. Generate header images for blog posts
1. Create quote cards for social posts
1. Build templates for consistent branding
1. Test 5 images, pick the best prompt settings
### Schedule and publish
Week 4 should have the following
1. Connect your publishing platforms (WordPress, Buffer, etc.)
1. Set up approval workflow (drafts save to review folder)
1. Create a scheduler that publishes approved content
1. Run the full pipeline end-to-end
Result after 4 weeks:
You have a system that researches topics, drafts content, generates images, and schedules publishing. You spend 1 hour per week reviewing. The system publishes 5 times per week.
For more on building AI-powered automation, see how to build and deploy a web app using only AI.
## Advanced: Multi-Channel Content Distribution
Once your core pipeline works, expand distribution.
Repurpose for video platforms:
- YouTube: turn blog posts into 5-minute explainer videos
- TikTok/Reels: extract 3 tips into 30-second videos
- YouTube Shorts: one key insight per short
Repurpose for audio:
- Podcast: long-form discussion of blog topic
- LinkedIn audio: 2-minute voice note summarizing post
- Clubhouse/Spaces: talking points from article
Repurpose for email:
- Newsletter: expanded version with exclusive insights
- Drip sequence: each section becomes one email
- Weekly roundup: combine 3 blog posts into digest
Distribution workflow:
```plaintext
1. Blog post published Monday 9am
2. Social posts Tuesday-Friday (LinkedIn, Twitter)
3. Newsletter Saturday morning
4. Video version published following Monday
5. Podcast episode following Wednesday
```
One piece of content feeds 2+ weeks of publishing across 6 platforms.
## Measuring What Matters
Track these metrics to improve your content pipeline:
Engagement metrics:
- Social post impressions and engagement rate
- Blog post views and time on page
- Email open rate and click rate
- Video view duration
Business metrics:
- Inbound leads from content
- Demo requests from CTAs
- Sales conversations started via DM
- Revenue attributed to content
Efficiency metrics:
- Time spent creating content per week
- Cost per piece (AI tool subscriptions)
- Content published per hour of work
- ROI: revenue ÷ content cost
Target: 20+ pieces of content per week with under 3 hours of work.
For content that converts, see how to use AI to find high-intent prospects for your freelance business.
## Tools and Costs
AI writing tools:
- Claude Pro: $20/month (best for long-form)
- GPT-4 API: ~$30/month for heavy use
- Jasper: $49/month (marketing-focused)
AI image tools:
- Midjourney: $30/month (high quality)
- DALL-E credits: ~$20/month
- Stable Diffusion: Free (self-hosted)
Video/audio tools:
- Descript: $24/month (video editing + transcription)
- ElevenLabs: $22/month (voice generation)
- Pictory: $29/month (text-to-video)
Publishing/scheduling:
- Buffer: $6/month per channel
- Zapier: $20/month (workflow automation)
- WordPress: $5/month (basic hosting)
Total monthly cost: $150-250/month for full automation stack.
ROI: if content generates 2 clients per month at $2,000 each, that's $4,000 revenue from $200 in tools. 20x return.
## Frequently Asked Questions
### How do I make AI content sound like me and not generic AI writing?
Create a voice guide document with your tone rules, banned phrases, and required elements. Include it in every prompt. Then edit the AI output to add your specific examples, stories, and hot takes. The AI handles structure and research; you add personality. Expect to spend 15-20 minutes editing a 1,500-word AI draft.
### Can I really automate content creation and still maintain quality?
Yes, but automation handles generation, not final approval. Set up workflows that draft content, save it to a review folder, and wait for your approval before publishing. You review once per week, approve or edit, then the system publishes on schedule. Quality control stays manual; the repetitive work gets automated.
### What's the difference between using AI manually versus automating it?
Manual AI use means you open ChatGPT, paste a prompt, get output, copy it to your blog. Automated AI means a script runs on schedule, generates content, saves drafts, and publishes approved pieces without you touching a keyboard. Manual saves time. Automation gives you leverage. You can publish 20 times per month with 3 hours of work.
### How do I handle AI-generated images that look obviously AI-made?
Use specific style prompts that match real photography or design trends. Add "photorealistic, natural lighting, shot on iPhone" for realistic images. For graphics, specify "minimalist, professional, clean typography, specific brand colors." Run 5-10 variations and pick the best one. Most AI image tools improve when you reference real styles instead of abstract concepts.
### Will Google penalize AI-generated content in search rankings?
Google's stance: they don't penalize AI content, they penalize low-quality content. If your AI-generated article answers the search query, includes original insights, and provides value, it ranks fine. The key: edit AI drafts to add your expertise, real examples, and data. Don't publish unedited AI output. Add the 20% that makes it yours.
### How long does it take to set up an automated content pipeline?
Expect 4 weeks to build a working system. After setup, you spend 1-2 hours per week reviewing and approving content. The system handles the other 10+ hours of work.
What if my industry requires deep expertise that AI doesn't have?
AI handles structure, research, and first drafts. You add the expertise. Use AI to draft a framework, then insert your specific insights, case studies, and contrarian takes. For technical content, AI can write the explainer sections while you write the advanced strategy sections. Treat AI as a research assistant and first-draft writer, not a replacement for your expertise.
---
Source: https://duet.so/blog/how-to-build-ai-seo-strategy-without-agency
# Build an AI-Powered SEO Strategy Without an Agency
*Fire your SEO agency or save the $5K/month before hiring one. Build an AI-powered SEO strategy that actually ranks.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 13 min read.
| Pillar | Monthly Tasks | AI Tool Used |
| ---------------- | ------------------------- | ----------------------- |
| Technical SEO | Crawl audit, fix issues | Screaming Frog + Claude |
| Keyword research | Find 50 target keywords | Ahrefs + Claude |
| Content creation | Publish 8-12 articles | Claude API |
| Link building | Outreach to 20 prospects | Clay + Claude |
| Tracking | Rankings + traffic review | GSC + Looker Studio |
SEO agencies are expensive, slow to show results, and often treat your site as one of 30 they're managing simultaneously.
For most startups and SMBs, the model doesn't work, you're paying $3,000-5,000 a month for work that could be done faster and more precisely with the right AI setup and a clear strategy.
This guide is for teams who want to own their SEO without outsourcing it.
We'll cover how to build a keyword strategy with AI, which tasks you can fully automate, how to produce content that actually ranks, and how to track progress without a $500/month analytics platform.
Everything here is practical and has been tested, no SEO theory, no vanity metrics.
**Quick Summary**
This guide covers how to build an AI-powered SEO strategy without hiring an agency — using AI for keyword research, content planning, technical audits, and link building so you can grow organic traffic on a startup budget.
**Questions this page answers**
- How to build an SEO strategy with AI
- Can AI replace an SEO agency?
- Best AI tools for SEO strategy
- How to do keyword research with AI
- How to grow organic traffic without an SEO agency?
## Why Agencies Charge $5,000/Month for Work You Can Automate
SEO agencies bill for three things: keyword research tools, analyst hours, and content production. A typical monthly retainer breaks down to $800 in tool subscriptions, $2,200 in research time, and $2,000 in content writing.
You can replicate this workflow with:
- DataForSEO API ($0.10 per 100 keyword queries)
- Firecrawl ($0.01 per page scraped)
- Claude Opus ($15 per million input tokens)
A complete monthly SEO campaign costs $40-$120 in API fees versus $5,000 in agency charges.
| Task | Free Option | Paid Option |
| ---------------- | -------------------------- | ------------------- |
| Keyword research | Google Keyword Planner | Ahrefs ($99/mo) |
| Technical audit | Screaming Frog (free tier) | Semrush ($120/mo) |
| Content writing | Claude.ai (free tier) | Claude API ($20/mo) |
| Rank tracking | Google Search Console | Ahrefs / Semrush |
| Link prospecting | Manual search | Hunter.io ($49/mo) |
The automation gap is closing fast. What used to require a team of analysts can now run in 20 minutes through connected AI tools. The bottleneck was never the analysis—it was coordinating multiple platforms and synthesizing the data.
## AI-Driven Keyword Research
Start with seed keywords from your product or service category. AI keyword research finds the gap between what you think customers search for and what they actually type.
### The Three-Tier Keyword Filter
Use this process to identify targets:
1. Seed extraction: Pull 200-500 keyword ideas from your primary topic
1. Intent filtering: Keep only commercial and transactional intent keywords
1. Difficulty scoring: Target keywords with KD 15-40 (Ahrefs scale)
Here's what the data looks like:
### Running This Through DataForSEO
DataForSEO returns keyword difficulty, search volume, CPC, and SERP features in one API call. The typical workflow:
```plaintext
Input: "ai seo tool"
Output: 347 related keywords with metrics
Filter: KD < 40, Volume > 100
Result: 43 target keywords
```
Most agencies run this analysis monthly and charge $800-$1,200 per report. The API call costs $0.35.
The real power comes from clustering related keywords into content topics. Instead of writing 43 separate articles, you write 8-12 comprehensive pieces that target multiple related searches.
For a complete guide to competitive intelligence automation, see How to Automate Competitive Intelligence.
## Analyze Competitor Content Gaps in Minutes
Competitor gap analysis means finding keywords your competitors rank for that you don't. Traditional agencies do this manually in spreadsheets over 4-6 hours.
### The Automated Gap Analysis Process
1. Pull your top 5 competitors' ranking keywords via DataForSEO
1. Compare against your current rankings
1. Filter for keywords where competitors rank in positions 1-10 and you don't rank
1. Sort by traffic potential (volume × CTR estimate)
The output looks like this:
This table tells you exactly where to focus content production. You're looking for patterns—topics where multiple competitors rank but you have no presence.
### Scraping Competitor Content Structure
Use Firecrawl to extract competitor article structures:
- Headings and subheadings
- Word count
- Internal linking patterns
- FAQ sections
- Image and media count
You're not copying content. You're reverse-engineering the content architecture that Google already validated by ranking it.
A competitor ranking #2 for "ai keyword research" has proven their structure works. Extract that structure, then fill it with better, more current information.
If you're scaling a marketing operation, read How to Scale a Marketing Agency Without Hiring.
## Generate Optimized Content Outlines from Keyword Clusters
Take your target keyword cluster and competitor research. Feed it to Claude with this prompt structure:
```plaintext
Keyword cluster: [list of 5-8 related keywords]
Top 3 competitor structures: [extracted H2/H3 patterns]
Target word count: 1,800-2,200
Audience: [persona]
Generate a content outline that:
- Covers all keywords naturally
- Improves on competitor gaps
- Follows E-E-A-T principles
```
Claude returns a structured outline in 15-30 seconds. The outline includes:
- Title optimized for primary keyword
- H2 sections covering semantic keyword variations
- Specific data points to include
- Internal linking opportunities
- FAQ section with long-tail keyword targets
### The Content Production Loop
Most agencies batch content production monthly. You can run this daily:
1. Identify keyword cluster (5 minutes via DataForSEO)
1. Pull competitor structures (10 minutes via Firecrawl)
1. Generate outline (1 minute via Claude)
1. Draft article (5-10 minutes via Claude)
1. Edit and publish (15-20 minutes)
Total time: 35-45 minutes per article versus 6-8 hours through an agency.
The quality difference is minimal if you provide good editing. Claude produces factually accurate, well-structured content. You add the expertise, examples, and brand voice.
For client deliverables, see How to Deliver Client SEO Audits in Hours.
## Track Rankings and Adjust Strategy Automatically
Ranking tracking used to require logging into Ahrefs or Semrush daily. Now you can automate position monitoring and trigger content updates when rankings slip.
### What to Track
When a keyword drops from position 4 to position 8, that's a 40% traffic loss. Most site owners don't notice until it's been weeks.
### Automated Response Workflows
Set up these triggers:
- Position drop: Re-scrape top 3 results, identify new content angles they added, update your article
- New competitor: Pull their backlink profile, identify linkable content gaps
- CTR underperformance: Test new title and meta description variations
- Keyword opportunity: New related keyword enters top 20, expand content to cover it
This is where AI compounds. The system monitors, identifies issues, proposes solutions, and can even draft the content updates automatically.
Traditional agencies report on these metrics monthly. You're reacting in real-time.
## Running This on a Persistent Cloud Server
The challenge with AI SEO workflows is persistence. You can't manually trigger keyword research, competitor analysis, and content generation every week.
The workflow breaks when you need:
- Scheduled weekly keyword position checks
- Automatic competitor content monitoring
- Triggered content updates on ranking drops
- Historical tracking of what worked
Desktop tools require you to be online and remember to run them. Cloud notebooks time out. Traditional automation platforms charge per workflow run.
A persistent cloud server solves this by running continuously in the background. You set up the workflow once, then it executes on schedule—checking rankings at 2am, analyzing competitors every Monday, generating content briefs when opportunities appear.
Duet provides this through long-running AI sessions that can access DataForSEO, Firecrawl, and 10,000+ other tools. You describe your SEO workflow in plain English, the system builds it, and it runs indefinitely. The same conversation that does your keyword research can schedule weekly position checks and alert you when action is needed.
This turns SEO from a monthly project into a continuous optimization engine. The AI maintains context across weeks, remembering which keywords you're targeting, what content performed, and where competitors are moving.
## The Complete Monthly SEO Workflow
Here's what a $5,000 agency retainer looks like when you automate it:
### Research & Discovery
- Pull 500 keyword ideas from seed topics (DataForSEO: $0.50)
- Filter to KD 15-40, commercial intent (Claude: $0.05)
- Cluster into 8-10 content topics (Claude: $0.10)
- Time: 30 minutes vs 8 hours agency
- Cost: $0.65 vs $1,200 agency
### Competitor Analysis
- Identify top 5 competitors per keyword cluster (DataForSEO: $0.75)
- Scrape competitor content structure (Firecrawl: $0.50)
- Gap analysis and opportunity ranking (Claude: $0.15)
- Time: 45 minutes vs 6 hours agency
- Cost: $1.40 vs $800 agency
### Content Production
- Generate 8 optimized outlines (Claude: $0.20)
- Draft 8 articles, 1,800-2,200 words each (Claude: $2.50)
- Edit and publish with internal linking (Manual: 3-4 hours)
- Time: 5-6 hours total vs 20-24 hours agency
- Cost: $2.70 vs $2,400 agency
### Monitoring & Optimization
- Daily position tracking for 50 keywords (DataForSEO: $1.50/week)
- Weekly traffic analysis (GA4: Free)
- Triggered content updates on position drops (Claude: $0.50)
- Time: 2 hours vs 4 hours agency
- Cost: $2.00 vs $600 agency
Monthly Total: $6.75 in API costs + 8-10 hours of your time vs $5,000 agency retainer.
The agency advantage used to be access to expensive tools and trained analysts. Now the tools are APIs anyone can use, and AI does the analysis better than junior analysts.
For related automation workflows, see How to Automate Content Creation for a One-Person Business.
## When to Still Consider an Agency
You need an agency when:
- Your site has 10,000+ pages requiring technical SEO
- You're in a highly competitive vertical (finance, legal, health) where E-E-A-T requires real credentials
- You need outreach link building at scale
- You have zero SEO knowledge and need strategic guidance
For most solopreneurs, small businesses, and even mid-sized companies, AI tools provide 80% of agency value at 2% of the cost.
The remaining 20% is strategic judgment—knowing which keywords to prioritize, when to pivot content angles, and how to build topical authority. You can learn this through practice faster than you can pay an agency $60,000 per year.
## Common Mistakes To Avoid Them
### Keyword Stuffing
AI generates content naturally, but you still need to edit. Don't force primary keywords into every paragraph. Google's algorithm is semantic, it understands topic relevance without exact-match keywords.
Rule: Primary keyword in title, one H2, and 2-3 times in body. Related keywords spread naturally.
### Thin Content
AI can produce 2,000 words on any topic. That doesn't mean it should. If a topic is fully covered in 800 words, stop there.
Rule: Match or exceed competitor word count only when you're adding new information.
### Ignoring User Intent
Search intent matters more than keyword difficulty. A KD 15 keyword that wants a product comparison won't convert if you write a how-to guide.
Rule: Analyze top 10 results before writing. If 8 of them are listicles, write a listicle.
### No Internal Linking
Every new article should link to 3-5 existing articles and be linked from 2-3 older pieces. This builds topical clusters that signal authority.
Rule: Map keyword clusters to content hubs. Link supporting articles to pillar content.
For AI-powered research workflows, see How to Use AI as Your Personal Research Assistant.
## Frequently Asked Questions
### Can AI really replace an SEO agency for keyword research?
Yes, for 90% of businesses. AI tools like DataForSEO and Claude can identify low-competition keywords, analyze search intent, and cluster topics in minutes. Agencies charge $800-$1,500 for monthly keyword research that costs $2-$5 in API calls. The analysis quality is identical or better because AI processes larger datasets without human bias or fatigue. You lose agency strategic judgment but gain speed and cost efficiency.
### How long does it take to see results from AI-powered SEO?
Expect 8-12 weeks for new content to rank, same as traditional SEO. AI doesn't speed up Google's crawling or indexing. The advantage is production speed—you can publish 8-10 optimized articles per month solo versus 2-3 without AI. More content targeting the right keywords means faster compounding results. Track position changes weekly but measure success quarterly.
### What's the best AI tool for competitor content analysis?
Firecrawl extracts clean content structure from competitor pages at $0.01 per page. Combine it with DataForSEO to pull competitor keyword rankings, then use Claude to identify content gaps. This three-tool workflow replicates what agencies charge $600-$1,000 per competitor analysis for under $5 in API costs. The analysis takes 15-20 minutes instead of 4-6 hours.
### Do I need coding skills to set up AI SEO automation?
No coding required. DataForSEO, Firecrawl, and Claude all have API access through tools like Duet where you describe workflows in plain English. If you can write "check keyword rankings every Monday and alert me if any drop more than 3 positions," the system builds it. The learning curve is understanding SEO fundamentals, not programming.
### How much does an AI-powered SEO workflow actually cost per month?
Budget $40-$120 per month depending on content volume. That breaks down to: DataForSEO keyword and ranking tracking ($15-$30), Firecrawl competitor scraping ($5-$15), Claude for content generation and analysis ($20-$75). Add $20-$30 if you use a persistent server for scheduled workflows. This replaces $3,000-$7,000 monthly agency retainers with identical output quality.
### Can AI-generated content rank as well as human-written content?
Yes, if properly edited. Google doesn't penalize AI content—it penalizes low-quality content. AI drafts need human review for accuracy, brand voice, and unique insights. The typical workflow is AI generates structure and first draft (10 minutes), human edits and adds expertise (15-20 minutes). This produces rankable content in 30 minutes versus 2-3 hours writing from scratch.
### What SEO tasks should I still do manually instead of automating?
Strategic decisions require human judgment: which topics to prioritize, when content angles aren't working, and relationship-based link building. Technical SEO audits benefit from expert review. Everything else—keyword research, competitor analysis, content drafting, position tracking—automates well. Spend your time on strategy and editing, not data collection and first drafts.
---
Source: https://duet.so/blog/how-to-build-and-deploy-a-web-app-using-only-ai
# Build and Deploy a Web App Using Only AI
*No dev team? No problem. Build and ship a fully functional web app using only AI — from idea to deployed in days.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 13 min read.
Two years ago, building a web app without a developer meant cobbling together Bubble, Webflow, and Zapier and hoping it held together.
Today, it means describing what you want in plain English and watching an AI generate the frontend, backend, and database schema in real time.
This is not a tutorial about simple landing pages or form builders.
This is about building and deploying a fully functional, production-ready web app using only AI, no coding required.
We'll cover what types of apps work well, which AI tools to use at each stage, how long it actually takes, and how to deploy without touching a command line.
**Quick Summary**
This guide covers how to build and deploy a fully functional web app using only AI — describing what you want in natural language, letting AI write and iterate the code, and deploying to production without writing a single line of code yourself.
**Questions this page answers**
- How to build a web app with AI without coding
- Can AI build and deploy a web app?
- Best AI tools for building web apps
- How to use Claude Code to build a web app
- What is vibe coding and how does it work?
AI can now build and deploy functional web applications from plain English descriptions — dashboards, landing pages, internal tools, APIs, and client portals — without you writing or deploying any code.
Describe what you want, review the output, iterate in conversation, and ship to a live URL in minutes to hours.
## Can You Really Build a Web App Without Coding?
Yes. AI can now build functional web apps from plain English descriptions. You describe what you want, the AI writes the code, and you can deploy it to a live URL without touching a single line yourself. This works for dashboards, landing pages, internal tools, APIs, calculators, client portals, and more. The process takes minutes to hours, not weeks.
The shift is called "vibe coding" — you communicate intent and requirements, the AI handles implementation. You still need to describe your app clearly, review what gets built, and iterate on the result. But you don't need to know React, Node.js, or CSS.
## What Kinds of Apps Can AI Build?
AI can build most common web applications, especially if they don't require complex backend logic or real-time collaboration features. Here's what works well:
AI struggles with apps that require real-time sync (like collaborative editors), complex state management across multiple users, or deep integrations with proprietary systems. But for most business tools, content sites, and internal utilities, AI can handle the full build.
## How Do You Describe Your App to AI?
The quality of your description determines the quality of the app. AI needs three things: purpose, features, and constraints.
**Purpose:** What problem does this app solve? Who uses it? Example: "A dashboard that shows our team's current project status so everyone knows what's blocked."
**Features:** What can users do? Be specific. Example: "Users can see a list of projects, mark tasks as complete, filter by status, and see who's assigned to each task."
**Constraints:** Tech preferences, design requirements, data sources. Example: "Use a simple JSON file for storage. Match our brand colors: blue (#27C08D) and white. No database required."
Start with a one-paragraph description. The AI will build a first version, and you can iterate from there. The more specific you are about edge cases, the fewer rounds of iteration you'll need.
## Steps To Build Your First AI App
### Write Your App Description
Open your AI tool and describe the app in plain English. Include purpose, features, and any technical constraints.
Example prompt:
> "Build me a team todo list app. It should let users add tasks, mark them complete, and delete them. Store todos in a JSON file. Use a clean, minimal design with a white background. Add a timestamp to each todo."
### Review the First Build
The AI will generate code and typically show you a preview or provide files. Check that:
- The core features work as described
- The design is acceptable
- Data persists (if storage was required)
- Edge cases are handled (empty states, long text, etc.)
Don't expect perfection on the first pass. Note what's missing or wrong.
### Iterate on the Result
Ask the AI to fix specific issues or add features. Be direct.
Example follow-ups:
> "The delete button doesn't work. Fix it."
> "Add a filter to show only incomplete tasks."
> "Change the primary button color to green (#27C08D)."
Most apps need 2-4 rounds of iteration. Complex apps might need 10+.
### Deploy to a Live URL
Once the app works locally or in preview, deploy it. Options:
- **Managed AI platforms:** Some AI tools host your app automatically and give you a URL
- **Static hosts:** Netlify, Vercel, GitHub Pages for frontend-only apps
- **Cloud servers:** AWS, DigitalOcean, Render for apps with backends
Ask the AI to generate deployment instructions for your chosen host. For static sites, you'll typically upload files. For backend apps, you'll push code to a server or container.
### Share the URL
Your app is now live. Share the URL with your team, clients, or users. The AI can help you add custom domains, SSL certificates, and access controls if needed.
## Examples of AI-Built Apps
### Public Analytics Dashboard
**Purpose:** Show real-time usage metrics for a SaaS product to customers.
**Features:**
- Display total API calls, active users, average response time
- Update every 5 minutes
- Responsive design for mobile and desktop
**Build time:** 45 minutes (including 3 rounds of iteration for styling and data refresh logic).
**Tech stack:** React, Chart.js, Node.js backend pulling data from a PostgreSQL database.
**Deployment:** Hosted on Render. Public URL shared with customers.
### Client Portal
**Purpose:** Let clients view their account usage and billing history without emailing support.
**Features:**
- Login with email link (passwordless)
- View usage charts for last 30 days
- Download invoices as PDFs
- See current subscription tier
**Build time:** 2 hours.
**Tech stack:** React frontend, Node.js backend, Stripe API integration, PDF generation with Puppeteer.
**Deployment:** Vercel for frontend, AWS Lambda for backend.
### Team Todo App
**Purpose:** Internal tool for tracking team tasks without using a heavy project management platform.
**Features:**
- Add, edit, delete todos
- Assign todos to team members
- Mark complete with timestamp
- JSON file storage (no database)
**Build time:** 30 minutes.
**Tech stack:** React, Node.js, JSON file backend.
**Deployment:** Single server instance, accessed via internal URL.
### Webhook Endpoint
**Purpose:** Receive webhooks from Stripe, transform the data, and send it to Slack.
**Features:**
- Accept POST requests from Stripe
- Parse payment events
- Format message for Slack
- Send to specific Slack channel
**Build time:** 20 minutes.
**Tech stack:** Node.js, Express, Slack API.
**Deployment:** AWS Lambda with API Gateway.
## How To Host and Maintain AI-Built Apps?
Your app needs to live on a server. Hosting options vary by app complexity.
### Frontend-Only Apps
Apps with no backend (static HTML/CSS/JS, React without a server) can be hosted on:
- **Netlify:** Free tier for small projects, automatic SSL, custom domains
- **Vercel:** Similar to Netlify, optimized for React/Next.js
- **GitHub Pages:** Free, works well for simple sites, requires Git repo
Deploy by uploading files or connecting a Git repository. Updates are pushed via Git or web interface.
### Apps with Backends
Apps that need a server (Node.js APIs, database connections, scheduled tasks) require:
- **Render:** Free tier for small apps, supports Node.js/Python/Go, automatic SSL
- **AWS (EC2, Lambda, Lightsail):** Full control, more complex setup, pay-as-you-go
- **DigitalOcean App Platform:** Simpler than AWS, flat-rate pricing
You'll typically push code to the host via Git, Docker, or direct upload. The host runs your server and provides a URL.
### Managed AI Platforms
Some AI coding tools host your app automatically. You describe and build the app, and the platform gives you a URL without manual deployment. This removes DevOps complexity but may limit customization or scale.
| Platform | Monthly Cost | Hosting Included | Best For |
| -------------- | ------------ | ---------------- | -------------------- |
| Cursor | $20 | No | Code-heavy apps |
| Bolt.new | $20 | Yes | Full-stack apps fast |
| Replit | $25 | Yes | Collaboration |
| v0 by Vercel | $20 | Via Vercel | React UIs |
| GitHub Copilot | $19 | No | Dev teams |
**Pricing comparison:**
### Maintaining and Updating Your App
Once live, you can ask the AI to update your app just like you built it. Common maintenance tasks:
- Fixing bugs reported by users
- Adding new features
- Updating designs or copy
- Changing data sources or APIs
Describe the change, the AI updates the code, and you redeploy. For managed platforms, updates may deploy automatically.
Set up monitoring so you know when your app breaks. Tools like Sentry (error tracking) and UptimeRobot (uptime monitoring) are free for small projects.
## When To Use AI to Build an App vs. Hiring a Developer?
| Use Case | AI Builder | Hire Developer |
| ------------------------ | --------------- | ----------------- |
| Internal tool / MVP | Best choice | Overkill |
| High-traffic public app | Risky | Recommended |
| Prototype / demo | Best choice | Too slow & costly |
| Mission-critical system | Not recommended | Required |
| Landing page / marketing | Best choice | Not needed |
AI is best for:
Hire a developer for:
The line is blurring. AI can now build production-grade apps for many use cases. But for mission-critical systems or apps that need long-term engineering ownership, human developers still make sense.
You can also combine both: use AI to build an MVP, validate the concept, then hire a developer to rebuild or refactor for scale.
## How Duet Handles the Full Build-Deploy Loop
Duet lets you describe an app in a durable session, and an AI agent writes the code and deploys it to a live URL from your workspace. No separate hosting account or manual deployment pipeline is required.
The process looks like this:
1. **Describe your app** in a Duet session. Example: "Build me a calculator app that computes project ROI based on cost and revenue inputs."
1. **The AI builds it** in real-time. You see the code being written and can preview the app as it's built.
1. **Deploy to a live URL** with one message. The app runs on your Duet server and you get a shareable link immediately.
1. **Update anytime** by asking the AI. "Change the button color to green." "Add a field for tax rate." The AI updates the code and redeploys.
This works for static apps (HTML/CSS/JS), React apps, Node.js backends, and APIs. Your apps live at subpaths on your Duet domain (e.g., `yourteam.duet.so/calculator`). You can build unlimited apps without separate hosting bills.
Duet also handles app state and data persistence. Apps can store data in JSON files, connect to external databases, or call third-party APIs. The AI manages the full stack.
For teams building internal tools, client-facing dashboards, or prototypes, this removes the entire DevOps layer. You go from idea to live app in one conversation. Learn more at [duet.so](/).
## What Are the Limits of AI-Built Apps?
AI-built apps have trade-offs. Understanding these helps you decide when to use AI vs. other approaches.
### Code Quality
AI-generated code works but isn't always optimal. You may see:
- Redundant logic or verbose code
- Inconsistent naming or structure
- Missing comments or documentation
- Inefficient algorithms for large datasets
For small apps and prototypes, this doesn't matter. For high-traffic production apps, you'll eventually want human review or refactoring.
### Complexity Ceiling
AI handles straightforward apps well. As complexity increases, AI struggles with:
- Multi-step workflows with many edge cases
- Complex state management across components
- Performance optimization for large datasets
- Deep integrations with proprietary systems
If your app description takes more than 2-3 paragraphs to explain, you're approaching AI's limit. Break it into smaller apps or bring in a developer.
### Debugging
When something breaks, AI can usually fix it if you describe the issue. But debugging complex failures (race conditions, memory leaks, cross-browser issues) is harder for AI than for experienced developers.
### Security
AI can implement basic security (input validation, HTTPS, environment variables). But for apps handling sensitive data, you should have a security expert review the code. AI may miss subtle vulnerabilities.
## Frequently Asked Questions
### Can AI build a web app without any coding knowledge?
Yes. AI can build functional web apps from plain English descriptions. You describe what you want, review the result, and request changes in natural language. No coding knowledge is required, though understanding basic web concepts (frontend vs. backend, APIs, hosting) helps you give better instructions.
### What types of web apps can AI build?
AI can build dashboards, landing pages, internal tools, APIs, calculators, client portals, form apps, and simple content sites. It works best for apps with straightforward logic and limited real-time collaboration. Complex apps with heavy state management or deep integrations may require developer assistance.
### How long does it take to build and deploy a web app with AI?
Simple apps (todo lists, calculators, landing pages) take 20-60 minutes including iteration. Medium-complexity apps (dashboards with charts, client portals with login) take 1-3 hours. Complex apps may take a full day or more, depending on feature count and polish requirements.
### Do I need to pay for hosting separately?
It depends on the tool. Managed AI platforms often include hosting in their subscription. If you build with standalone AI tools (like Claude Code or Cursor), you'll deploy to a separate host like Netlify, Vercel, or AWS. Some hosts offer free tiers for small projects.
### Can I update my AI-built app later?
Yes. Describe the changes you want (bug fixes, new features, design updates), and the AI will update the code. Redeploy the updated version to your host. This works for both small tweaks and major feature additions, though larger changes may require multiple iteration rounds.
### Is the code quality good enough for production?
For internal tools and MVPs, yes. For high-traffic public apps or mission-critical systems, AI-generated code may need developer review and refactoring. The code works but isn't always optimized for performance, security, or maintainability at scale.
### How much does it cost to build and host a web app with AI?
AI tool costs range from $20-100+/month depending on the platform. Hosting costs range from free (Netlify, Vercel, Render free tiers) to $7-50+/month for backend apps with traffic. Total monthly cost for a simple app: $20-50. For comparison, hiring a developer for a similar project costs $2,000-10,000+ upfront.
---
Source: https://duet.so/blog/how-to-build-client-analytics-dashboard-without-developer
# Build a Client Analytics Dashboard Without a Dev
*Give clients real-time analytics dashboards without hiring a developer. Build it in a day using AI — seriously.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 15 min read.
Every agency and consultant has had this moment.
You've got great results to show a client, but the data is spread across Google Analytics, Meta Ads, a spreadsheet, and three different platform dashboards.
Putting together the monthly report takes half a day.
The client looks at it for 10 minutes.
AI changes what's possible here. You can now build a live client analytics dashboard, pulling from every data source that matters, updating automatically, with a plain-English summary the client can actually understand, without writing a line of code.
This guide covers the tools, the tech stack, what to include, and how to charge for it.
**Quick Summary**
This guide covers how to build a client analytics dashboard without a developer — using AI to generate code, connect data sources, and deploy a live dashboard your clients can access, going from brief to working product in under a day.
**Questions this page answers**
- How to build an analytics dashboard without a developer
- Best AI tools for building dashboards
- Can AI build a client analytics dashboard?
- How to create a data dashboard using AI
- How to automate client reporting with AI?
---
## Why Do Clients Want Custom Dashboards?
| Layer | Tool | Purpose |
| ------------- | --------------------------- | ----------------------- |
| Data source | GA4 / Shopify / HubSpot API | Pull raw data |
| Processing | Python / Node.js | Aggregate & calculate |
| Storage | Supabase / Airtable | Store processed metrics |
| Visualisation | Retool / Grafana / React | Display charts |
| Sharing | Embedded URL / PDF export | Client delivery |
Clients pay premium rates for real-time visibility into their metrics. A custom dashboard replaces weekly email reports with live data they can check anytime.
Benefits agencies charge for:
- Eliminate reporting calls. Clients see updates without asking.
- White-label branding. Your logo, their data.
- Competitive differentiation. Most competitors send static PDFs.
- Retention tool. Clients who monitor dashboards daily stick around longer.
Agencies charge $500-2,000/month for dashboard access. Traditional development costs $5,000-15,000 upfront plus maintenance.
## What Dashboard Types Can AI Build?
AI handles most client deliverable formats. You describe the layout and data sources in plain language.
Most dashboards combine 2-4 data sources. AI creates dropdowns, date filters, and export buttons automatically when you describe them.
## How Does AI Build a Dashboard From Conversation?
Modern AI tools translate natural language descriptions into functional web applications. The process takes 30-90 minutes for most dashboards.
Three-step framework:
1. Describe what you want. "Build a dashboard showing Google Ads spend by campaign, weekly conversion trends, and cost per lead."
1. AI writes the code. Creates HTML, CSS, JavaScript with chart libraries (Chart.js, D3.js).
1. Deploy to public URL. One-click publishing to a shareable link.
No coding knowledge required. You review the output, request changes ("make the chart bar instead of line"), and publish when satisfied.
## Building Your First Client Dashboard
### Define Dashboard Requirements
List exactly what your client needs to see. Be specific about timeframes and comparisons.
Example brief:
- Total ad spend (current month vs. last month)
- Conversion rate by campaign (sortable table)
- Daily leads chart (last 30 days)
- Cost per acquisition trend (weekly)
Write this in a document. Include metric definitions if your client uses custom terminology.
### Gather Data Sources
Determine where each metric comes from. Most dashboards use spreadsheets initially, then upgrade to API connections.
Data source options:
- CSV uploads. Export from existing tools, upload to dashboard.
- Google Sheets. Share a sheet, AI reads data directly via API.
- Direct API connections. Google Ads, Facebook, HubSpot, Salesforce.
- Manual entry. Simple forms for one-off updates.
Start with CSV files. You can connect live APIs later without rebuilding.
### Describe Dashboard to AI
Open your AI tool and describe each section. Use this template:
```plaintext
Build a client dashboard with these sections:
1. Header: Company logo, dashboard title, last updated timestamp
2. KPI Cards: Four boxes showing total spend, total conversions, average CPA, ROAS
3. Line Chart: Daily conversions for the last 30 days
4. Table: Campaign performance with columns for campaign name, spend, conversions, CPA, ROAS (sortable)
5. Footer: Export to PDF button
Data source: I'll upload a CSV with columns: date, campaign_name, spend, conversions
Color scheme: Blue primary (#0066CC), white background, gray text (#333333)
```
The AI generates code in 2-5 minutes.
### Review and Refine
AI shows you a preview. Test every interactive element—filters, sorting, date pickers.
Common refinement requests:
- "Change the chart from bars to lines"
- "Add a dropdown to filter by campaign type"
- "Make the table font smaller"
- "Show currency as dollars with two decimals"
Each change takes 30-90 seconds. Iterate until the dashboard matches your vision.
### Deploy to Public URL
Click deploy. The AI publishes your dashboard to a permanent URL like yourname-client-dashboard.platform.com.
Deployment checklist:
- [ ] Test on mobile and desktop
- [ ] Verify all data displays correctly
- [ ] Check page load speed (should be under 3 seconds)
- [ ] Confirm branding elements (logo, colors)
Copy the URL and send to your client. No login required unless you add password protection.
### Update Data Regularly
Upload new CSVs weekly or monthly. For live data, connect APIs once the client approves the dashboard layout.
Update workflow:
1. Export fresh data from your tools
1. Upload to dashboard (usually a simple file picker)
1. Dashboard auto-refreshes with new charts
Set a calendar reminder. Most agencies update client dashboards every Monday morning.
## How to Connect Live Data Sources
Static CSV uploads work for MVPs. Live API connections eliminate manual updates.
### Google Sheets Integration
Share a Google Sheet with view access. AI reads data in real-time.
Setup:
1. Create a Google Sheet with your data
1. Share with "anyone with link can view"
1. Give AI the sheet URL
1. AI fetches data every time someone loads the dashboard
Update the sheet, dashboard updates automatically. No re-deployment needed.
### API Connections
Direct API access requires authentication tokens. Most platforms provide them in settings.
Common API sources:
- Google Ads (OAuth setup via Google Cloud Console)
- Facebook Ads Manager (access tokens from Meta for Developers)
- HubSpot (API key from account settings)
- Google Analytics (OAuth similar to Google Ads)
AI generates the API connection code when you provide credentials. Data refreshes hourly or daily based on your configuration.
### Webhook Receivers
For event-driven updates (new form submission, purchase completed), AI can create webhook endpoints.
Example use case: Lead tracking dashboard. When Typeform receives a submission, it sends data to your dashboard webhook. New lead appears instantly.
Setup takes 10-15 minutes. You get a webhook URL, paste it into your form tool's integration settings.
## Examples
### Campaign Performance Dashboard
Client: Real estate agency running Google and Facebook ads.
Metrics displayed:
- Total monthly spend vs. budget
- Lead volume by channel (stacked bar chart)
- Cost per qualified lead (line chart with 90-day trend)
- Ad creative performance (table with CTR, conversion rate, spend)
Data sources: Google Ads API, Facebook Ads API, Google Sheets (manual qualification status).
Build time: 1.5 hours. Monthly update time: 15 minutes (updating qualification statuses).
### Lead Tracking Dashboard
Client: B2B SaaS company tracking pipeline stages.
Metrics displayed:
- Leads by stage (funnel chart)
- Conversion rate between stages (percentage badges)
- Average days in each stage (comparison to last quarter)
- Individual lead details (searchable table)
Data sources: HubSpot CRM API.
Build time: 2 hours. Monthly update time: Zero (live API connection).
### Content Analytics Dashboard
Client: Content marketing agency managing 12 client blogs.
Metrics displayed:
- Traffic by client (dropdown selector)
- Top 10 posts by pageviews (bar chart)
- Organic search traffic trend (line chart, 6 months)
- Keyword rankings for target terms (table with position change indicators)
Data sources: Google Analytics API, SEMrush CSV exports.
Build time: 2.5 hours. Monthly update time: 30 minutes (uploading SEMrush data).
## Cost Compared to Traditional Development?
Traditional dashboard development requires frontend and backend developers plus ongoing maintenance.
AI-built dashboards eliminate developer costs. You pay only for hosting (usually $10-30/month for most traffic levels).
Pricing comparison for hosting:
- Netlify/Vercel free tier: Up to 100GB bandwidth. Fine for most client dashboards.
- Paid hosting: $20-50/month for unlimited bandwidth and custom domains.
## What About Duet for Building Dashboards?
Duet combines conversational AI with a built-in deployment system designed for building custom applications. You describe the dashboard you need, and Duet's AI writes the code, creates the interface, and publishes it to a public URL—all within the same conversation.
How it works:
1. Tell Duet what dashboard you need: "Build a client dashboard showing campaign spend, conversions, and ROAS with a line chart and table."
1. Duet generates a functional web app with interactive charts and data tables.
1. Deploy to a permanent public URL like client-dashboard--yourworkspace.edge.duet.so.
1. Share the link with your client.
The process takes 30-60 minutes for most dashboards. If you need changes, you continue the conversation: "Make the chart bigger" or "Add a date filter." Duet updates the code and redeploys instantly.
Data connection options: Upload CSV files, connect Google Sheets, or integrate APIs. Duet handles the technical setup when you describe the data source.
You can explore Duet at duet.so.
## How To Handle Client Data Security?
Client dashboards display sensitive business metrics. Security should match or exceed what clients expect from enterprise tools.
### Password Protection
Add basic authentication to restrict access. Most AI tools generate login screens when you request them.
Implementation: "Add password protection. Username is 'client' and password is 'XYZ123'."
Change passwords quarterly. Use unique credentials per client.
### HTTPS Encryption
All modern hosting platforms (Netlify, Vercel, Cloudflare Pages) provide free SSL certificates. Data transmits encrypted.
Verify: Dashboard URL should start with https:// not http://.
### Data Storage
Two approaches:
1. Client-side only. Dashboard fetches data from Google Sheets or APIs directly in the browser. No data stored on your server.
1. Backend database. Data cached on your server for faster loading. Requires secure database setup.
For most client dashboards, client-side data fetching is simpler and secure enough.
### Access Logs
Track who views the dashboard and when. Some platforms provide analytics automatically.
Purpose: If a client asks "who looked at this?", you have records.
## How Do You White-Label Dashboards?
Remove all platform branding. Add your agency logo and colors.
White-labeling checklist:
- [ ] Replace default logo with your agency logo
- [ ] Set primary color to your brand color
- [ ] Add "Powered by [Your Agency]" footer
- [ ] Use custom domain (dashboard.youragency.com instead of platform subdomain)
Custom domains cost $10-20/year. Most hosting platforms allow domain mapping in settings.
Custom domain setup:
1. Buy domain from Namecheap or Google Domains
1. Add CNAME record pointing to your dashboard host
1. Configure custom domain in hosting platform settings
Takes 15-30 minutes. Clients see your brand, not the AI tool's brand.
## How To Charge Clients for Dashboard Access?
Dashboard access is a recurring revenue line item. Price based on value, not cost to build.
Pricing models:
Value-based pricing example: If your dashboard saves a client 5 hours/month of manual reporting, charge based on what 5 hours of their time is worth ($500-1,500).
Present it as "real-time reporting access" in your proposals. Clients compare it to alternatives (hiring a BI analyst, buying Tableau licenses).
| Tool | Best For | Cost |
| ------------- | -------------------------------- | ------------------ |
| Retool | Internal & client ops dashboards | $10+/user/mo |
| Looker Studio | Google data visualization | Free |
| Metabase | SQL-based business analytics | Free (self-hosted) |
| Grafana | Technical / time-series metrics | Free (self-hosted) |
| Custom React | Full control + custom branding | Dev time only |
## What Chart Types Should You Use?
Match chart type to the metric. Wrong visualizations confuse clients.
Common dashboard metrics and best chart types:
- Trends over time: Line charts (daily conversions, monthly revenue)
- Comparisons between categories: Bar charts (spend by campaign, traffic by channel)
- Part-to-whole relationships: Pie charts or donut charts (budget allocation, traffic source mix)
- Progress toward goal: Gauge charts or progress bars (80% of monthly target)
- Volume and detail: Tables with sorting and filtering
Use color consistently. Green for positive metrics (revenue, conversions), red for alerts (over budget, declining traffic).
Limit charts to 4-6 per dashboard. Too many visuals overwhelm clients.
## How Often Should Dashboards Update?
Update frequency depends on data volatility and client expectations.
Recommended refresh rates:
- Real-time (every minute): E-commerce sales dashboards, live campaign monitoring
- Hourly: Social media metrics, ad performance during active campaigns
- Daily: SEO rankings, content performance, lead generation
- Weekly: Long-term trends, monthly progress tracking
- Manual: Client requests refresh when they need current data
Set expectations upfront. "This dashboard updates every morning at 6 AM EST with yesterday's data."
For CSV-based dashboards, update weekly or monthly depending on your workflow.
## How Do You Export Dashboard Data?
Clients want to download data for their own analysis or presentations.
Export options to include:
- PDF export: Full dashboard snapshot. Good for presentations.
- CSV export: Raw data tables. Clients import into Excel.
- Image export: Individual charts for reports.
- Email scheduling: Automated PDF sent weekly.
AI tools generate export buttons when you request them. "Add a 'Download as PDF' button in the top right."
### PDF Export Setup
Tell the AI: "Add a button that exports the entire dashboard to PDF."
PDF configuration options:
- Page size (letter, A4, or custom)
- Include/exclude certain sections
- Add cover page with client logo
- Orientation (portrait or landscape)
### Automated Email Reports
Some clients want weekly PDF snapshots emailed automatically.
Setup: Use a scheduling service (Zapier, Make.com) to:
1. Trigger every Monday at 8 AM
1. Capture dashboard screenshot or generate PDF
1. Email to client stakeholders
Takes 20-30 minutes to configure. Clients love the proactive delivery.
## Frequently Asked Questions
### Can I build a dashboard without knowing how to code?
Yes. Modern AI tools translate plain language descriptions into functional dashboards. You describe what you want—"show monthly revenue as a line chart with a table of top customers below it"—and the AI generates the code. The entire process happens through conversation. No programming knowledge required.
### How long does it take to build a client dashboard using AI?
Most dashboards go live in 1-4 hours. Simple dashboards with 3-4 metrics take 30-60 minutes. Complex dashboards with multiple data sources, custom filters, and advanced charts take 2-4 hours. The time includes describing requirements, reviewing AI output, making refinements, and deploying to a public URL.
### What data sources can I connect to a dashboard?
AI-built dashboards connect to Google Sheets, CSV uploads, REST APIs, and webhooks. Common integrations include Google Ads, Facebook Ads, Google Analytics, HubSpot, Salesforce, Stripe, and any platform with an API. For tools without APIs, you export data as CSV and upload it weekly or monthly. You can also build custom forms for manual data entry.
### How much does it cost to host a client dashboard?
Hosting costs $0-50/month depending on traffic and features. Free tiers from platforms like Netlify and Vercel handle most client dashboards (up to 100GB bandwidth/month). Paid hosting ($20-50/month) provides custom domains, higher bandwidth, and password protection. Enterprise hosting with advanced security costs $100-200/month but is rarely needed for standard client dashboards.
### Can clients access dashboards on mobile devices?
Yes. AI-generated dashboards work on all devices. Charts and tables automatically resize for mobile screens. Test the dashboard on both desktop and mobile before sharing with clients. Most platforms provide mobile preview tools during development. If something looks off on mobile, ask the AI to "make the dashboard mobile-responsive with smaller fonts and stacked charts."
### How do I keep client data secure on a dashboard?
Add password protection, use HTTPS encryption (standard on all modern hosting), and minimize data storage. For maximum security, configure dashboards to fetch data directly from Google Sheets or APIs in the client's browser—no data stored on your server. Change passwords quarterly. For enterprise clients with strict requirements, use single sign-on (SSO) or IP whitelisting. Most AI tools can implement these features when you describe the security requirements.
### What if I need to change the dashboard after deployment?
Tell the AI what to change and it updates the code. Changes deploy in minutes. Common updates include adding new metrics, changing chart types, updating colors, or adding filters. You don't need to rebuild from scratch. For major redesigns, create a new version and test before replacing the live dashboard. Keep the old URL active until the client approves the new version.
---
---
Source: https://duet.so/blog/how-to-build-internal-tool-in-a-day-with-ai
# How to Build and Ship an Internal Tool in a Day Using AI
*Your team needs it, engineering is backlogged. Build and ship a working internal tool in a single day using AI — no dev required.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 11 min read.
Modern team these days have that one spreadsheet that's become load-bearing infrastructure. It was supposed to be temporary.
Now six people depend on it, it breaks when someone adds a new row, and everyone secretly dreads the day it corrupts.
The real fix is a proper internal tool, but 'proper internal tool' means a developer sprint, a requirements doc, and three weeks of back-and-forth.
With AI, you can go from 'we need a tool for this' to a deployed, working internal tool in a single day.
This guide covers which tools are realistic to build in a day, how to spec them clearly, how to ensure they're secure enough to use, and what maintenance looks like without a dedicated developer.
**Quick Summary**
This guide walks through how to build and ship a working internal tool in a single day using AI — from describing what you need to having a deployed, functional tool your team can use without any developers.
**Questions this page answers**
- How to build an internal tool in one day with AI
- Best AI tools for building internal tools fast
- Can AI build a working internal tool without developers?
- How to ship internal software quickly using AI
- How to build internal tools without coding?
## Internal Tools As Startup Bottleneck
Internal tools are essential but chronically under-prioritized. Every startup needs dashboards to track metrics, admin panels to manage users, and custom analytics views for different stakeholders.
The problem: engineering time is scarce. Your team is focused on product features that directly impact customers and revenue. Building a support ticket dashboard or an investor update generator feels like overhead.
Traditional options all have drawbacks:
- Build it yourself: Takes 3-5 days of engineering time per tool
- Off-the-shelf SaaS: Rigid, doesn't fit your data model, monthly fees per seat
- No-code tools: Limited to simple CRUD operations, breaks at scale
- Outsource it: Expensive, slow feedback loop, maintenance burden
The result: most startups run on spreadsheets, manual Slack updates, and SQL queries pasted into documents. The friction compounds as you grow.
## How AI Builds Functional Web Apps from Conversation
Modern AI coding assistants can write complete applications from a conversational prompt. This isn't code autocomplete or snippet generation. It's end-to-end app construction.
Here's what happens behind the scenes:
1. You describe the tool: "Build a customer lookup dashboard that shows account status, MRR, and recent support tickets"
1. AI generates the stack: React frontend, Node.js API, database queries, styling, routing
1. AI handles deployment: Generates build configs, sets up the server, creates a public URL
1. You iterate: "Add a filter by plan type" AI updates the code and redeploys
The AI understands context from your existing codebase. If you mention "customers," it knows your schema. If you say "dashboard," it applies your design system.
For ai business analytics, this means you can spin up custom reporting views in the time it takes to write a Slack message.
## Step-by-Step: Building an Analytics Dashboard with AI
### 1. Start with a Clear Description
Be specific about what you need. Instead of "build a dashboard," say:
"Build a real-time analytics dashboard that shows:
- Active users in the last 24 hours
- Revenue by plan tier (bar chart)
- Top 10 customers by usage
- Conversion funnel from trial to paid
- Filterable by date range"
### 2. Let the AI Generate the Stack
The AI will choose appropriate technologies based on your requirements:
- Frontend: React with Recharts for visualizations
- Backend: Express API or serverless functions
- Data layer: SQL queries or API calls to your existing database
- Styling: Tailwind CSS or your existing design tokens
You don't need to specify these. The AI makes reasonable choices and you can adjust later.
### 3. Review and Iterate in Real Time
The AI builds the first version in 2-3 minutes. You'll see:
- A live preview URL
- The full source code
- Console logs if anything breaks
Test it immediately. If the conversion funnel calculation is wrong, say: "The funnel should track distinct users, not total events." The AI updates the logic and redeploys.
### 4. Deploy to a Public URL
Once you're satisfied, the tool is already live at a public URL. Share it with your team:
- your-company.example.com/analytics-dashboard
- No Vercel account needed
- No AWS console configuration
- No Docker files or CI/CD pipelines
The AI handles the hosting infrastructure. You just share the link.
## Internal Tools Built in One Day
### Customer Lookup Tool
Use case: Support team needs fast access to account details without writing SQL.
Prompt: "Build a customer lookup tool. Search by email or company name. Show account status, plan tier, MRR, signup date, and last 5 support tickets."
Result: Single-page app with search bar, customer card layout, and ticket timeline. Deployed in 20 minutes.
### Weekly Investor Update Generator
Use case: CEO spends 2 hours every Friday compiling metrics for investors.
Prompt: "Build an investor update generator. Pull this week's data: user growth, revenue, burn rate, runway, top feature usage. Format as email-ready HTML."
Result: One-click report generation. Reduces update prep from 2 hours to 5 minutes.
### Feature Flag Admin Panel
Use case: Product team needs to toggle feature flags without deploying code.
Prompt: "Build a feature flag admin panel. List all flags, show which are enabled, allow toggle on/off with confirmation dialog. Log all changes."
Result: Full CRUD interface with audit trail. No more asking engineers to flip flags in production.
### Sales Pipeline Dashboard
Use case: Sales team needs visibility into deal stages and forecasted revenue.
Prompt: "Build a sales pipeline dashboard. Show deals by stage (kanban view), total pipeline value, weighted forecast, and stale deals over 30 days."
Result: Drag-and-drop board with real-time updates. Replaces weekly spreadsheet exports.
## The "Apps" Model
The traditional development workflow looks like this:
1. Write code locally
1. Test in development environment
1. Commit to Git
1. Deploy to staging
1. Test again
1. Deploy to production
1. Configure DNS, SSL, monitoring
For internal tools, this overhead is absurd. You're adding a search box to a dashboard, not launching a payment system.
The AI-native workflow collapses this to:
1. Describe what you want
1. Use the live tool
The "apps" model treats internal tools as ephemeral artifacts. The AI builds it, hosts it on your infrastructure, and gives you a URL. If you need to change it next week, you just ask.
This works because internal tools have different requirements than customer-facing products:
- Uptime: 95% is fine, it's internal
- Scale: Hundreds of users, not millions
- Security: Behind SSO, not public internet
- Iteration speed: More valuable than polish
## Duet As The Solution
Duet is a conversational app building and instant deployment platform.
Duet takes this approach further by integrating app building into a durable workspace session. Start the session with the outcome you need:
"Build an analytics dashboard that shows our top customers by revenue this month."
The AI writes the code in real-time, deploys it to a URL on Duet's infrastructure, and replies with the link. The app is live immediately at your-team.duet.so/analytics-dashboard.
You can iterate by continuing the conversation:
- "Add a filter by industry vertical"
- "Make the revenue chart a line graph instead of bars"
- "Export this data as CSV"
Each change updates the live app. There's no deploy step, no build process, no infrastructure to configure. The app is just a conversation artifact that happens to have a public URL.
This model works because Duet handles the entire stack: code generation, hosting, routing, and access control. Your team gets SSO-protected tools without DevOps overhead. Learn more at duet.so.
## When to Use AI for Internal Tools
AI for product development excels at specific use cases. Use it when:
- The requirements are clear: You know exactly what data to show and how
- It's read-heavy: Dashboards, reports, lookup tools
- It's internal-only: Behind authentication, small user base
- Speed matters more than perfection: Ship today, refine later
Don't use it when:
- Security is critical: Payment processing, PII handling, compliance-sensitive operations
- You need complex business logic: Multi-step workflows with edge cases
- It's customer-facing: High polish and reliability requirements
- You'll need to maintain it for years: Better to invest in proper architecture
For the 80% of internal tools that are "just show me this data in a table," AI is the fastest path to done.
## AI vs. Traditional Development
Building a customer lookup dashboard traditionally:
- Engineer time: 3 days at $100/hour = $2,400
- Deployment setup: 4 hours = $400
- Maintenance: 2 hours/month = $200/month
- Total first month: $3,000
Building the same tool with AI:
- AI usage: 15 minutes of compute = $2
- Hosting: Included in platform cost or ~$5/month
- Maintenance: Conversational updates, ~$1/month in AI usage
- Total first month: $7
The math is absurd. Even factoring in iteration time and testing, AI-built internal tools are 100x cheaper for the same outcome.
## Evolution of Product Development Workflows
When internal tools are this cheap, you build more of them. Instead of one "admin dashboard," you build:
- A dashboard for support
- A different one for sales
- Another for executives
- A custom view for each investor
Each stakeholder gets exactly the data they need, in the format they prefer, without engineering becoming a bottleneck.
This shifts product development from "what can we afford to build?" to "what would be useful?" The constraint is no longer engineering time but your imagination.
Teams report building 5-10 internal tools in the first week after adopting AI development workflows. These aren't throwaway prototypes. They're production tools that the team uses daily.
## Frequently Asked Questions
### Can AI build tools that connect to my existing database?
Yes. AI coding assistants can generate database queries for PostgreSQL, MySQL, MongoDB, and other common databases. You provide connection credentials (securely, via environment variables), and the AI writes the queries based on your schema. For tools that need to read from multiple sources, the AI can orchestrate API calls to your existing services.
### How do I handle authentication for internal tools built by AI?
Most AI development platforms include built-in authentication. You can configure SSO with Google Workspace, Okta, or other identity providers. The AI generates the auth flow and protects routes automatically. For simpler setups, basic auth or API keys work fine for internal-only tools.
### What happens if the AI-generated code has bugs?
You iterate conversationally. Say "the revenue calculation is showing $0 for all customers" and the AI debugs and fixes it. Because the AI has full context of the code it wrote, debugging is faster than traditional development. For production-critical tools, you should review the generated code or add tests.
### Can I customize the design of AI-built tools?
Absolutely. You can provide a design system or styling guidelines in your initial prompt: "Use our company colors (primary: #27C08D, background: #FBFDFC) and Geist Sans font." The AI applies these styles. You can also iterate: "Make the cards rounded with drop shadows" or "Use a darker shade for the header."
### How do AI-built tools compare to no-code platforms like Retool or Airtable?
AI-built tools are fully custom code, so they're more flexible than no-code platforms. You're not constrained by predefined components or data models. However, no-code platforms offer better collaboration features and admin UIs for non-technical users. Use AI when you need custom logic or unusual layouts. Use no-code when you need team-wide editing.
### Is the code portable if I want to move off the AI platform?
Yes. The generated code is standard React, Node.js, Python, or whatever stack the AI chose. You can export it and deploy to your own infrastructure. Most AI development platforms let you download the full source code at any time.
The main limitation is complexity. AI excels at CRUD apps, dashboards, and data visualization. It struggles with intricate business logic, real-time collaboration features, or complex state management. For simple internal tools (80% of what startups need), there's genuinely no catch. For the remaining 20%, you'll still need traditional development.
---
Source: https://duet.so/blog/how-to-choose-the-right-ai-model-for-your-business
# How to Choose the Right AI Model for Your Business: Grok vs Gemini vs Claude vs GPT-5.5
*A practical guide to picking the right AI model per task — Claude for writing, GPT-5.5 for code, Gemini for long context, Grok for real-time. How to run all four without four logins.*
By Duet Team. Published 2026-05-16. 11 min read.
The right AI model for your business depends on the task: use Claude for nuanced writing and reasoning, Grok for real-time research tied to current events, Gemini for long documents and spreadsheets, and GPT-5.5 for code, agents, and general-purpose work. Most businesses need at least two — picking a single model locks you into one provider's blind spots.
This guide walks through what each model is actually good at, when to use which, and how to run all four from one place without juggling four subscriptions.
**Quick Summary**
The four frontier model families — Claude, GPT-5.5, Gemini, and Grok — now lead on different dimensions. Pick by task, not by provider: Claude wins on writing and judgment, GPT-5.5 on code and agents, Gemini on long context, Grok on real-time data.
## Why the "one AI to rule them all" era is over
A year ago, picking an AI tool meant picking a provider. ChatGPT or Claude. Pick one, live with it.
That's no longer how serious operators work. The four frontier model families — Anthropic's Claude, OpenAI's GPT, Google's Gemini, and xAI's Grok — have diverged in what they're good at. Each leads on different benchmarks. Each has access to different data. Each costs different amounts per task.
If you're running a real business with AI doing real work — writing, research, code, customer ops — using a single provider means you're getting B+ output on tasks where a different model would get you an A. Over hundreds of tasks per month, that compounds.
The shift: pick the model per task, not per subscription.
## The four frontier models at a glance
| Model | Best for | Weakness | Notable strength |
| ---------------------- | ------------------------------------------------------- | -------------------------------------- | ------------------------------------------------------------------------- |
| **Claude (Anthropic)** | Long-form writing, nuanced reasoning, code review | No real-time web access by default | Highest-rated writing quality; strong refusal behavior on sensitive tasks |
| **GPT-5.5 (OpenAI)** | General-purpose work, code, agents, multimodal | Can be verbose; less distinctive voice | Largest ecosystem; strongest agentic tool-use |
| **Gemini (Google)** | Long documents, spreadsheets, research over big context | Less polished prose | 2M-token context window; native Google Workspace integration |
| **Grok (xAI)** | Real-time research, current events, X/Twitter data | Smaller ecosystem; newer | Native access to live X data; less filtered on current-events queries |
Use this as the cheat sheet. The rest of the article gets specific.
## When to use Claude
Claude is the writing model. If you're producing customer-facing copy, internal memos, proposals, or anything where voice and reasoning matter more than raw speed, Claude is the default pick.
Specific tasks where Claude wins:
- **Long-form writing** — blog posts, sales emails, customer responses. Claude's prose is consistently the most natural.
- **Nuanced reasoning** — judgment calls, ethical tradeoffs, multi-step logic where you'd want a thoughtful colleague to think it through.
- **Code review** — Claude is excellent at reading code and explaining what it does or what's wrong, even if GPT-5.5 is now neck-and-neck on writing new code.
- **Editing** — handing Claude a draft and asking for a tighter version usually beats every other model.
When to avoid Claude: anything that needs current information from the web (Claude doesn't browse by default), or high-volume agentic loops where cost per token matters.
## When to use GPT-5.5
GPT-5.5 is the workhorse. It's the model with the deepest tool ecosystem, the strongest agent loop, and the broadest "good enough at everything" surface area.
Specific tasks where GPT-5.5 wins:
- **Code generation** — building new features, scaffolding apps, writing scripts. Currently the leader on most coding benchmarks.
- **Agentic workflows** — anything that requires the model to plan, call tools, check results, and iterate. GPT-5.5's tool-use reliability is the best in class.
- **Multimodal tasks** — analyzing images, screenshots, charts, or working from a mix of text and visuals.
- **General-purpose business tasks** — summarization, drafting, brainstorming where you don't have a strong preference.
When to avoid GPT-5.5: when you want a distinctive voice (it's competent but generic), or when you're processing massive documents that exceed its working context.
## When to use Gemini
Gemini is the long-context model. Google's 2M-token context window is roughly 10x what competitors offer at the high end. That's not a marketing number — it changes what's possible.
Specific tasks where Gemini wins:
- **Long documents** — read an entire contract, board deck, or research report and ask questions across the whole thing.
- **Spreadsheet analysis** — paste in a 50,000-row CSV and ask for patterns. Gemini handles tabular data well.
- **Cross-referencing** — give it ten documents at once and ask how they relate. Most models truncate; Gemini reads it all.
- **Google Workspace work** — if your business runs on Docs, Sheets, and Gmail, Gemini's native integration is hard to beat.
When to avoid Gemini: short conversational tasks where the long-context strength is wasted, or copywriting where Claude's prose quality wins.
## When to use Grok
Grok is the real-time model. It's the only frontier model with native access to live X (Twitter) data, and it tends to be less hedged on current-events questions than the others.
Specific tasks where Grok wins:
- **Real-time research** — what is the market saying about [topic] right now? Grok pulls from live feeds.
- **News monitoring** — track a competitor announcement, an industry event, a developing story.
- **Social listening** — what are people on X actually saying about your brand or category?
- **Less-filtered answers** — Grok is willing to engage with edgier business questions (legal, political, contested topics) that other models hedge on.
When to avoid Grok: anything where you need maximum reasoning depth or polished writing — Grok's strength is speed and freshness, not nuance.
## A simple decision tree
A practical rule of thumb most operators converge on:
1. **Does it need fresh information from the web or X?** → **Grok**
2. **Is it more than 100 pages of context?** → **Gemini**
3. **Is voice, judgment, or writing quality the main thing?** → **Claude**
4. **Everything else, especially code or agents?** → **GPT-5.5**
Run this four-step check before kicking off any non-trivial task. Most businesses save 10–20% on AI quality by routing intentionally instead of defaulting to one provider.
## What this costs in practice
A small business using AI heavily — say, 5 hours of AI-assisted work per day across writing, research, and code — is looking at roughly $20–80/month per provider on direct API access, or $20–40/month per provider on consumer plans.
Subscribing to all four directly means:
- ChatGPT Plus: $20/month
- Claude Pro: $20/month
- Gemini Advanced: $20/month
- Grok (X Premium+): $40/month
That's roughly $100/month and four separate logins. Most operators don't do this — they pick one and live with the gaps.
The alternative is to use a single workspace that routes to all four models. One monthly plan includes credits, the paid reserve covers overage, and you can switch models per task without juggling logins. We'll get to that below.
## How to actually run multi-model workflows
The decision tree above is easy in theory. In practice, the friction is operational:
- You'd need to log in to four different apps to use four different models.
- Each app has its own memory, history, file uploads, and integrations.
- You can't chain tasks across models (e.g., Grok researches, Claude writes the email, GPT-5.5 ships it).
- You can't run anything 24/7 without keeping your laptop open.
This is where the workflow breaks down for most people. The fix is to run AI from a persistent cloud workspace that talks to all four providers, holds shared memory and files, and can run scheduled or webhook-triggered tasks in the background.
[Duet](/) is one way to do this. Every workspace gives you a private cloud server with all four model providers available in the same picker, shared file storage, persistent memory across conversations, cron scheduling, and the ability to host apps your AI builds for you. You can ask Grok to monitor X for competitor news every morning, hand the summary to Claude to draft a response, and have GPT-5.5 deploy a dashboard — all in one workspace, all running while your laptop is closed.
The point isn't the tool. The point is that "use the best model per task" only works if the cost of switching between models is near zero.
## Common mistakes when picking AI models
A few patterns that cost businesses time and money:
- **Defaulting to one model out of habit.** If you've used ChatGPT for two years, you'll instinctively send everything to GPT — even tasks where Claude or Gemini would be better. Fight the default.
- **Picking by hype instead of fit.** Every model launch claims to be "the best." Benchmarks shift weekly. What matters is which model is best at your task today.
- **Ignoring context limits.** Pasting a 200-page document into a model with a 32K context window means most of your document was silently discarded. Check the limit.
- **Treating cost as a tiebreaker too early.** A model that's 20% cheaper but produces output you have to rewrite costs more, not less. Quality first, cost second.
- **Not testing in parallel.** For any task you do repeatedly (weekly reports, sales emails, content drafts), run the same prompt through all four models once. Pick the winner. Use that one going forward for that task.
## What's next
The four-model landscape will keep shifting. Expect:
- More specialized models for specific verticals (legal AI, medical AI, coding AI).
- Smaller, faster open-source models that are good enough for most tasks at near-zero cost.
- Routing becoming an invisible layer — you'll stop picking models and start picking tasks.
In the meantime, the operators who get the most out of AI right now are the ones who treat the model picker like a tool rack, not a single hammer.
## Frequently Asked Questions
### Which AI model is best for small business owners?
For most small business owners, Claude is the best default for writing and customer-facing work, and GPT-5.5 is the best default for everything else. Add Gemini if you work in long documents or Google Workspace, and add Grok if you need real-time market or social listening. Most businesses get the highest leverage from running at least two models, not one.
### Can I use Claude, GPT, Gemini, and Grok all at once?
Yes. You can either subscribe to each provider directly (about $100/month total across four plans) or use a unified workspace that gives you access to all four on a single credit balance with shared memory and files. The unified approach is significantly less friction if you switch between models often.
### Is Grok better than ChatGPT for business?
Grok is better than GPT-5.5 only for real-time tasks — news monitoring, current-events research, and pulling live data from X. For everything else (writing, code, general business tasks, agents), GPT-5.5 is more capable. Grok is best treated as a specialist tool alongside one of the other three models, not a replacement.
### Which AI model has the largest context window?
Gemini currently has the largest context window at 2 million tokens, roughly 1,500 pages of text. Claude offers 200K tokens (about 500 pages), GPT-5.5 offers 272K (about 600 pages), and Grok offers around 128K. If your tasks involve reading long contracts, full research reports, or large datasets, Gemini's context window is a meaningful advantage.
### How much should a small business spend on AI per month?
A reasonable starting budget is $50–150/month for a single operator doing daily AI-assisted work. This covers either consumer subscriptions across two to four providers, or a credit-based workspace with usage across all providers. Businesses that run AI 24/7 for monitoring, outreach, or background processing typically spend $200–500/month and see strong ROI from automation.
### Do I need to know how to code to use multiple AI models?
No. Most multi-model workflows now use a guided product surface: choose the model, assign the task, and inspect the result. Tools such as Duet, OpenAI's GPTs, and Claude Projects let non-technical users run multi-step work without writing code. Coding still matters when you need to route hundreds of tasks programmatically.
### Will one AI model eventually be best at everything?
Unlikely in the next two to three years. The four major model families are now optimized for different goals — Anthropic for safety and writing, OpenAI for agents and tools, Google for context and integration, xAI for real-time data. As long as the providers compete on different dimensions, the right strategy is to use the best one per task rather than waiting for a single winner.
---
Source: https://duet.so/blog/how-to-create-marketing-videos-with-ai
# Create Professional Marketing Videos with AI
*AI marketing video creation without a video team — the text to video for marketing workflow that ships scroll-stopping videos in hours.*
By Duet Team. Published 2026-03-01, updated 2026-04-19. 12 min read.
Video content is non-negotiable for marketing in 2026 but traditional production is slow, expensive, and completely out of reach for most small teams. A single explainer video from a production agency can run $3,000-10,000 and take three weeks. By the time it's done, the campaign it was made for has already moved on.
AI marketing video creation has flipped this model. You can now go from a brief to a polished, professional marketing video in hours, not weeks for a fraction of the cost.
This guide covers the best AI video tools available right now, when to use each, how text to video for marketing actually works end to end, how to maintain brand consistency at scale, and how to produce content that looks like your team made it.
**Quick Summary**
This guide shows how to create professional marketing videos using AI, from scripting and voiceover to visuals and editing, going from brief to finished video without a production team.
**Questions this page answers**
- How to create marketing videos with AI
- Best AI tools for video marketing
- Can AI create professional marketing videos?
- How to make videos with AI without a production team
- What are the best AI video generators in 2026?
AI marketing video creation lets you produce professional marketing videos without filming equipment or expensive editing software. Modern text to video for marketing tools generate visuals from written prompts, add professional voiceovers, and assemble complete videos in minutes. This workflow costs $20-50 per video instead of $500-2000 for traditional video production.
| Tool | Use Case | Cost/Month |
| ----------- | --------------------------- | ---------- |
| HeyGen | AI avatar presenter | $29+ |
| Runway | Video generation & editing | $15+ |
| ElevenLabs | Voiceover / narration | $5+ |
| Canva Video | Templates & motion graphics | $13+ |
| Synthesia | AI presenter videos | $29+ |
| Step | Task | Time |
| ---- | ------------------------------- | ------ |
| 1 | Write script with AI | 15 min |
| 2 | Generate voiceover (ElevenLabs) | 5 min |
| 3 | Create visuals (Runway/Canva) | 20 min |
| 4 | Assemble in video editor | 15 min |
| 5 | Export & publish | 5 min |
## Why Do Small Businesses Skip Video Content?
Video outperforms static content across every platform.
YouTube videos get 1200% more shares than text and images combined.
LinkedIn video posts generate 5x more engagement than image posts. Instagram Reels reach 300% more accounts than regular posts.
Most SMBs avoid video because traditional production requires cameras, lighting, editing skills, and time. A 60-second product explainer traditionally costs $1,500-3,000 and takes 2-4 weeks. AI video content creation removes these barriers entirely.
## What Does the AI Marketing Video Creation Workflow Look Like?
The complete workflow has five stages:
1. **Script generation** - AI writes the narrative
1. **Visual creation** - AI generates images or scenes
1. **Animation** - Static images become video clips
1. **Voiceover** - Text-to-speech adds narration
1. **Assembly** - Combine clips, audio, and transitions
Each step takes 2-10 minutes. Total production time: 30-60 minutes for a polished 60-second video.
## How Do You Create a 60-Second Product Explainer Video?
### Step 1: Write the Script
Start with a one-paragraph product description. AI expands it into a video script with scene descriptions.
Example input: "Productivity app that blocks distracting websites during work hours and tracks deep work sessions."
AI output:
- Scene 1 (0-15s): Person frustrated by social media notifications
- Scene 2 (15-30s): App interface blocking distractions
- Scene 3 (30-45s): Productivity dashboard showing 4 hours deep work
- Scene 4 (45-60s): User celebrating completed project
Each scene gets specific visual direction and narration text.
### Step 2: Generate Images for Each Scene
Use AI image generation for each scene. Fal AI, Midjourney, and DALL-E 3 all work. Specify consistent style across scenes.
Prompt template: "[Scene description] in [style], [composition details], [lighting], [color palette]"
Example: "Professional woman closing laptop confidently in modern office, minimalist style, centered composition, natural window light, blue and white color palette"
Generate 2-3 variations per scene. Select the best match. Cost: $0.10-0.50 per image.
### Step 3: Animate Static Images into Video
Animation tools convert images to video clips. Options include:
Upload each image with motion instructions: "camera slowly zooms in" or "subject turns head and smiles."
Generate multiple takes. Animation quality varies. Budget 2-3 attempts per scene.
### Step 4: Create Professional Voiceover
Text-to-speech has reached professional quality. ElevenLabs and Play.ht generate indistinguishable-from-human narration.
Feed your script into the TTS tool. Select voice characteristics:
- Age and gender
- Accent (American, British, Australian)
- Tone (energetic, calm, authoritative)
- Speaking pace (words per minute)
Preview 3-5 voices. Pick the best match for your brand. Cost: $0.15-0.30 per minute of audio.
### Step 5: Assemble the Complete Video
Video editing platforms combine your assets:
**Free options:**
- DaVinci Resolve (desktop)
- CapCut (web and mobile)
- Clipchamp (web)
**Paid options:**
- Adobe Premiere Pro ($22.99/month)
- Final Cut Pro ($299 one-time)
- Descript ($24/month, includes TTS)
Import video clips, voiceover audio, and background music. Arrange on timeline. Add transitions between scenes. Include text overlays for key points. Export in platform-specific formats.
| Video Type | AI Tool | Platform |
| -------------------- | ------------------- | ------------------- |
| Product demo | Synthesia / HeyGen | YouTube, LinkedIn |
| Testimonial-style | HeyGen | Facebook, Instagram |
| Explainer / tutorial | Runway + ElevenLabs | YouTube |
| Social short | Canva + CapCut AI | TikTok, Reels |
## What Are the Platform-Specific Requirements?
Different platforms demand different specifications:
Create one master video in 1080x1920 (vertical). Export square (1:1) and horizontal (16:9) versions as needed.
**Optimization tips:**
- First 3 seconds determine 65% of watch-through rate
- Add captions (85% watch with sound off)
- Include visual hook before title card
- Place CTA at 45-50 seconds for 60-second videos
## How Much Does AI Video Creation Actually Cost?
Traditional video production pricing:
AI video creation pricing per 60-second video:
- Script generation: $0.05-0.20 (API costs)
- Image generation: $0.40-2.00 (4 scenes)
- Animation: $2.00-4.00 (4 clips)
- Voiceover: $0.15-0.30
- Editing software: $0-25/month
**Total per video:** $2.60-6.50 plus editing software subscription.
Create 100 videos for what one traditional video costs.
## What AI Tools Should You Use for Each Step?
**Script Writing:**
- Claude Opus (best for marketing copy)
- GPT-4o (good general purpose)
- Gemini 2.5 Pro (free tier available)
**Image Generation:**
- Fal AI (fast, consistent quality)
- Midjourney (highest aesthetic quality)
- DALL-E 3 (best prompt following)
**Video Animation:**
- Fal AI Kling (best motion quality)
- Runway Gen-3 (cinematic effects)
- Pika Labs (creative style control)
**Voiceover:**
- ElevenLabs (most natural voices)
- Play.ht (good value, fast)
- Microsoft Azure TTS (enterprise option)
**Video Editing:**
- DaVinci Resolve (free, professional)
- CapCut (beginner-friendly)
- Descript (AI editing features)
Mix and match based on budget and quality needs. Test free tiers before paying for subscriptions.
## How Do You Scale Production to Multiple Videos Per Week?
### Build a Template System
Create reusable templates for common video types:
- Product demos
- Customer testimonials
- How-to tutorials
- Feature announcements
- Social proof compilations
Each template includes:
- Script structure with fill-in-the-blank sections
- Scene sequence and transitions
- Brand colors and fonts
- Music track and sound effects
- Lower third graphics
Production time drops from 60 minutes to 15-20 minutes per video with templates.
### Batch Production Process
Produce videos in batches of 5-10:
**Monday:** Script all videos
**Tuesday:** Generate all images
**Wednesday:** Create all animations
**Thursday:** Produce all voiceovers
**Friday:** Edit and export all videos
Batching reduces context switching. Complete one task type across multiple videos before moving to the next stage.
### Repurpose Content
Turn one long-form video into multiple short-form pieces:
- 10-minute YouTube video → 15 Shorts/Reels
- Webinar recording → 20 social clips
- Product demo → 8 feature-specific videos
Extract the best 30-60 second segments. Add new voiceover for context. Export in platform-specific formats.
## Brand Consistency Across AI-Generated Videos
Maintaining visual consistency requires specific techniques:
**Image Generation:**
- Use identical style prompts across all videos
- Reference specific art styles or aesthetics
- Include brand color codes in prompts
- Generate character reference images and reuse
**Voiceover:**
- Clone your own voice or a brand spokesperson
- Use the same TTS voice across all videos
- Create pronunciation dictionaries for brand terms
- Maintain consistent speaking pace (150-160 WPM for most content)
**Video Assembly:**
- Build brand templates with standard intro/outro
- Use consistent font families and sizes
- Apply the same color grading across clips
- Reuse transition styles and timing
## How To Automate Video Pipeline?
Connect AI tools into a continuous workflow. When you need to generate marketing videos at scale without manual intervention, automation handles the repetitive tasks.
Duet runs on persistent cloud servers and coordinates multiple AI services simultaneously. Describe your video concept in plain text. The system generates the script, creates visuals, produces animation, synthesizes voiceover, and assembles the final video. Results appear in your workspace within 20-30 minutes.
The media creation pipeline handles image generation through Fal AI, video animation through multiple providers, and text-to-speech through ElevenLabs. Everything runs in the background while you focus on distribution strategy. Access the platform at [duet.so](/).
For teams producing 10+ videos weekly, automation reduces per-video time from 60 minutes to 5 minutes of input. The system maintains brand consistency automatically through stored templates and style parameters.
## What Results Should You Expect?
Video content drives measurable business outcomes:
### Engagement metrics
- 1200% more social shares than text posts
- 80% increase in landing page conversion rates
- 95% message retention vs 10% for text
- 5x higher click-through rates in email
### Platform-specific performance
- LinkedIn: Video posts get 5x more engagement
- Instagram: Reels reach 300% more accounts
- X: Video tweets get 10x more engagement
- YouTube: Shorts get 3x more views than regular videos
### Sales impact
- 84% of consumers purchased after watching brand video
- 96% watch explainer videos to learn about products
- 88% were convinced to buy by brand's video
Create 2-3 videos weekly for 90 days. Track view counts, engagement rates, and conversion metrics. Adjust content strategy based on performance data.
## Frequently Asked Questions
### What is the best AI video maker for beginners?
CapCut offers the most beginner-friendly interface for AI marketing video creation. The web version requires no download and includes automatic captioning, background removal, and text-to-speech. Free tier provides 720p exports with watermark. Paid version ($9.99/month) removes watermark and unlocks 4K export. Mobile app syncs projects across devices for editing on the go.
### Which text to video for marketing tool produces the most natural results in 2026?
For text to video for marketing, Runway Gen-3 and Fal AI Kling lead on motion realism and prompt adherence as of 2026. Runway produces cinematic 10-second clips with strong camera control and consistent lighting; Fal's Kling integration handles complex subject motion and longer sequences. For talking-head style marketing videos, HeyGen and Synthesia convert a script directly into a presenter-led video with lip-synced voiceover in under 10 minutes. Pick based on format: cinematic B-roll (Runway), presenter explainer (HeyGen), social-first short (Pika + CapCut).
### How to create a marketing video without a camera or filming equipment?
Generate all visuals using AI image creation tools like Midjourney or DALL-E 3. Create 4-6 images representing your video scenes. Animate static images into video clips using Runway or Pika Labs. Add professional voiceover with ElevenLabs text-to-speech. Assemble everything in free editing software like DaVinci Resolve. Total production time: 30-60 minutes per video without touching a camera.
### Which AI voiceover tool sounds realistic?
ElevenLabs produces the most natural-sounding AI voices as of 2026. The platform offers voice cloning from 1 minute of sample audio and generates speech with appropriate emotion, pacing, and inflection. Professional tier ($99/month) includes commercial usage rights and unlimited voice clones. Play.ht offers comparable quality at lower cost ($39/month) with slightly less emotional range.
### What video length performs best on social media platforms?
YouTube Shorts and Instagram Reels perform best at 45-60 seconds. TikTok engagement peaks at 21-34 seconds. LinkedIn video sweet spot is 60-90 seconds for educational content. Facebook shows drop off after 1 minute. Create master videos at 60 seconds, then trim to platform-specific lengths. Front-load value in first 3 seconds to maximize watch-through rate.
### How much does AI video creation cost compared to hiring a video editor?
Freelance video editors charge $500-2,000 per finished minute. AI video creation costs $3-7 per finished minute including image generation, animation, and voiceover. Monthly software subscriptions add $50-150 total. Producing 10 videos monthly costs $6,500-20,000 with freelancers versus $530-1,650 with AI tools. Break-even point is 2-3 videos monthly.
### Can AI-generated videos rank on YouTube and appear in search results?
YouTube algorithms treat AI-generated videos identically to traditionally filmed content. Ranking factors include watch time, click-through rate, engagement, and metadata quality. Add accurate titles, descriptions, and tags. Include human-reviewed captions for accessibility and SEO. Disclose AI generation in video description. Thousands of AI-generated channels achieve monetization and ranking success.
### What is the fastest way to create video content for multiple social platforms?
Create one master video in 1080x1920 vertical format. Use DaVinci Resolve's timeline export feature to generate multiple aspect ratios simultaneously. Export 9:16 for Shorts/Reels/TikTok, 1:1 for Instagram feed and LinkedIn, and 16:9 for YouTube and Facebook. Add platform-specific intros and CTAs using batch processing. Generate 5 platform versions from 1 master video in 15-20 minutes.
---
Source: https://duet.so/blog/how-to-deliver-client-seo-audits-in-hours
# How to Deliver Client SEO Audits in Hours Instead of Weeks
*Stop burning 3 weeks on SEO audits. Deliver comprehensive client audits in hours using AI, and charge the same rates.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 13 min read.
# How to Deliver Client SEO Audits in Hours
If you know seo, you understand that the traditional SEO audit takes a week.
You crawl the site, export the data, manually review hundreds of URLs, compile findings into a slide deck, and by the time you present it, half the issues you flagged have already changed.
It's slow, it's expensive to deliver, and most clients don't read past page 3 anyway.
AI-assisted SEO audits change the economics completely.
The same depth of analysis, technical crawl, on-page review, content gaps, competitor benchmarking, can now be done in 2-6 hours.
This guide covers the tools, the workflow, and how to turn raw audit data into a prioritised action plan your clients can actually act on.
Quick Summary
This guide shows how to deliver comprehensive client SEO audits in hours instead of weeks using AI, automating crawl analysis, keyword gap identification, competitor benchmarking, and report generation.
Questions this page answers
- How to deliver SEO audits faster with AI
- Best AI tools for SEO auditing
- How to automate client SEO reports with AI
- Can AI replace manual SEO audit processes?
- How to scale an SEO agency with AI
## What Does a Comprehensive SEO Audit Include?
A full SEO audit covers technical health, content quality, keyword strategy, and competitive positioning. Agencies charge $3,000 to $10,000 for these audits because they require manual analysis across multiple tools.
Standard audit components:
Total manual time: 28-42 hours for a mid-sized client site.
That timeline assumes the analyst knows what they're doing. Junior analysts take longer. Most agencies batch audits across 2-3 weeks because no one can dedicate full days to a single audit.
## How Can AI Automate 90% of the SEO Audit Process?
AI seo optimization tools automate data collection, analysis, and report generation. You still provide strategic oversight, but the grunt work disappears.
What AI handles automatically:
1. Technical crawling - Firecrawl or Screaming Frog scans every page for broken links, missing meta tags, slow load times, and mobile issues
1. Keyword research - DataForSEO pulls current rankings, search volumes, and keyword difficulty scores across thousands of terms
1. Content scoring - AI evaluates each page against top-ranking competitors, identifies thin content, flags duplicate issues
1. Competitor benchmarking - Automated analysis of competitor backlink profiles, ranking overlaps, and content gaps
1. Report generation - AI formats findings into client-ready PDFs with charts, tables, and prioritized action items
What you still do: Review findings, add strategic context, present recommendations to clients.
The best ai seo tool setups combine multiple data sources. DataForSEO for keyword data, Firecrawl for site crawls, Ahrefs or SEMrush APIs for backlink analysis. AI stitches everything together and writes the analysis.
## How Do I Run a Full SEO Audit From a Single Conversation?
Set up an AI agent with access to SEO data sources. Then give it the client's domain and competitors.
Step-by-step process:
### Step 1: Configure SEO Data Access
Connect your AI agent to DataForSEO, Firecrawl, and any backlink APIs you use. Most AI platforms let you add API keys through skill configurations or tool integrations.
Required credentials:
- DataForSEO API key (for keyword data)
- Firecrawl API key (for site crawling)
- Optional: Ahrefs, SEMrush, or Moz API for backlinks
### Step 2: Initiate the Audit
Start a conversation with your AI agent. Provide the client domain and 3-5 competitor domains.
Example prompt:
```plaintext
Run a complete SEO audit for clientsite.com.
Competitors: competitor1.com, competitor2.com, competitor3.com.
Include technical crawl, keyword analysis, content audit, and competitive gaps.
Generate a PDF report with charts.
```
### Step 3: Monitor Data Collection
The AI agent will run parallel tasks:
- Firecrawl crawls the client site (10-30 minutes for 500-1000 pages)
- DataForSEO pulls keyword rankings and search volumes (5-10 minutes)
- Competitor analysis runs simultaneously (15-20 minutes)
You'll see progress updates as each data source returns results.
### Step 4: Review Automated Analysis
The AI analyzes findings and identifies priority issues. It categorizes problems by severity and potential traffic impact.
Common findings the AI flags:
- High-priority: Broken internal links, pages blocked from indexing, slow Core Web Vitals scores
- Medium-priority: Missing H1 tags, thin content under 300 words, duplicate title tags
- Low-priority: Missing alt text on non-critical images, minor mobile usability issues
### Step 5: Customize Recommendations
Review the AI's recommendations. Add strategic context specific to the client's business goals. Remove any generic advice that doesn't apply.
Example customization:
The AI might flag "thin content on product pages." You add: "Expand product descriptions to 500+ words. Include use cases, technical specs, and customer FAQs. Priority: pages with existing top-20 rankings."
### Step 6: Generate the Report
Ask the AI to format everything into a client-ready PDF. Specify sections, chart types, and branding.
Example prompt:
```plaintext
Create a PDF report with:
- Executive summary (1 page)
- Technical issues with screenshots (3-4 pages)
- Keyword opportunities table (1 page)
- Content audit with priority scores (2 pages)
- Competitor benchmark charts (2 pages)
- Recommendations roadmap (1 page)
Use the client's brand colors and logo from [URL].
```
Total time from start to PDF: 2-3 hours. Most of that is data collection. Your active time is 30-45 minutes.
## How To Generate Client-Ready Reports With Charts and Tables?
AI agents can create formatted PDFs if they have access to document generation tools. You provide the data structure and visual preferences.
Required capabilities:
- PDF generation (libraries like Puppeteer, wkhtmltopdf, or cloud services)
- Chart creation (Chart.js, D3.js, or similar)
- Template customization (HTML/CSS for branded layouts)
Report structure that clients expect:
### Executive Summary
One-page overview with:
- Current SEO health score (0-100)
- Traffic opportunity estimate (monthly organic visits)
- Top 3 priority fixes
- Estimated implementation timeline
### Technical SEO Section
Table of critical issues:
Include screenshots for major problems. Clients want to see the actual issue, not just descriptions.
### Keyword Analysis
Two charts:
1. Current rankings distribution - Bar chart showing how many keywords rank in positions 1-3, 4-10, 11-20, 21-50
1. Keyword opportunity matrix - Scatter plot with search volume on X-axis, ranking difficulty on Y-axis. Highlight quick wins (high volume, low difficulty, currently unranked)
Table of top 20 keyword opportunities with monthly search volume, current position, and target position.
### Content Audit
Spreadsheet-style table:
Include a summary: "78 pages below 300 words. 45 pages with duplicate title tags. 23 blog posts with no internal links."
### Competitor Benchmark
Side-by-side comparison chart:
Highlight gaps: "Competitor 1 ranks for 2,644 keywords we don't target. Represents ~15,000 monthly visits."
### Recommendations Roadmap
Prioritized action plan with effort estimates:
Month 1 (Quick Wins):
- Fix 47 broken internal links (2 hours)
- Add missing meta descriptions (4 hours)
- Optimize 23 high-opportunity pages (16 hours)
Month 2-3 (Content Expansion):
- Expand 78 thin content pages (40 hours)
- Create 15 new pages targeting keyword gaps (60 hours)
Month 4-6 (Technical + Authority):
- Implement schema markup (8 hours)
- Launch link building campaign (ongoing)
Total estimated time: Agencies typically quote this as a 3-6 month engagement. The audit itself validates that scope.
## How To Automate Recurring Client Audits?
Set up monthly audit jobs that run automatically. Compare current data to previous months and highlight changes.
Implementation steps:
### Step 1: Create a Scheduled Task
Use cron jobs, GitHub Actions, or serverless functions to trigger audits monthly. Pass the client domain and report template.
Example cron syntax (runs 1st of each month at 9 AM):
```plaintext
0 9 1 * * /path/to/audit-script.sh clientsite.com
```
### Step 2: Store Historical Data
Save each month's raw data (rankings, crawl results, metrics). AI needs historical context to identify trends.
Data structure:
```plaintext
/audits/clientsite.com/
2026-01-data.json
2026-02-data.json
2026-03-data.json
```
### Step 3: Configure Trend Analysis
Program the AI to compare month-over-month changes:
- Ranking improvements/declines
- New issues vs. resolved issues
- Traffic growth or drops
- Competitor movements
Example trend report section:
"Rankings improved for 47 keywords (avg. +4.2 positions). 12 keywords declined (avg. -2.8 positions). New technical issues: 8 broken links, 3 redirect chains. Resolved issues: 34 missing meta descriptions, 15 slow pages."
### Step 4: Auto-Generate Progress Reports
The AI creates a "progress since last audit" section. Clients see what improved, what regressed, and what new opportunities appeared.
Progress report template:
- Executive summary of changes
- Rankings: wins, losses, net change
- Technical: issues fixed vs. new issues
- Content: pages optimized this month
- Next month's priorities
### Step 5: Alert on Critical Changes
Set up notifications for major issues:
- Site goes down or blocks search engines
- Rankings drop significantly (20+ positions for important keywords)
- Competitor launches major content
- Backlink profile changes dramatically
Example alert: "ALERT: clientsite.com rankings dropped avg. 12 positions for 23 keywords in last 7 days. Possible Google algorithm update or technical issue. Investigate immediately."
Time savings: Manual recurring audits take 10-15 hours per client per month. Automated audits take 0 active hours. You review the report in 15-20 minutes and present findings.
## When To Use AI vs. Manual SEO Analysis?
Use AI for data collection and pattern recognition. Use manual analysis for strategic decisions and client-specific context.
What AI handles better:
What humans handle better:
The hybrid workflow: AI does 90% of the work (data + analysis). You do 10% (strategy + presentation). Total time drops from 30-40 hours to 2-4 hours per audit.
For agencies running audits for multiple clients, this is the difference between handling 2-3 audits per month vs. 20-30 audits per month with the same team.
## What Tools Are Needed for Automated SEO Audits?
You need keyword data, site crawling, and document generation. Most setups use 3-5 tools.
Core tool stack:
Budget setup (under $200/mo):
- DataForSEO for keyword data ($99/mo)
- Firecrawl for site crawls (free tier or $39/mo)
- Duet for AI analysis and report generation ($20/mo)
- Open-source PDF tools (Puppeteer, wkhtmltopdf)
Premium setup ($600-$1,200/mo):
- SEMrush or Ahrefs full suite ($399-$499/mo)
- Screaming Frog or OnCrawl ($149-$299/mo)
- Duet or enterprise AI ($100-$200/mo)
- DocRaptor or similar ($99/mo)
The premium setup handles more data volume and provides deeper backlink analysis. The budget setup delivers 80% of the value for agencies just starting with automated audits.
### How Duet Handles the Complete Workflow
Duet connects to DataForSEO for keyword research, Firecrawl for site crawling, and runs AI analysis on a persistent server. You ask for an audit in one message. Duet orchestrates all the data collection, analyzes findings, and generates a PDF report with charts.
The persistent server means long-running crawls don't timeout. Firecrawl can crawl 1,000+ pages while Duet handles keyword analysis in parallel. When data collection finishes, Duet writes the analysis, creates charts using Chart.js or similar, and compiles everything into a branded PDF.
Example workflow in Duet:
```plaintext
"Run a full SEO audit for clientdomain.com.
Competitors: comp1.com, comp2.com, comp3.com.
Use the client's brand colors: primary #27C08D,
background #FBFDFC. Generate a PDF report."
```
Duet handles the rest. Two hours later, you have a 12-15 page report ready to send. duet.so
## Frequently Asked Questions
### Can AI really replace manual SEO audits?
AI replaces the data collection and pattern recognition work. It crawls sites, pulls keyword data, identifies technical issues, and formats reports faster than humans. What it doesn't replace: strategic thinking, client-specific prioritization, and business context. A good AI audit takes 2-3 hours and covers everything a $5,000 manual audit covers. You still review findings and present recommendations. The difference is you spend 3 hours instead of 30 hours per audit.
### What's the accuracy of AI-generated SEO recommendations?
AI recommendations are as accurate as the data sources feeding them. DataForSEO, Ahrefs, and Firecrawl provide the same data human analysts use. The AI applies standard SEO best practices: fix broken links, optimize thin content, target keyword gaps. Where AI sometimes misses context: understanding a client's business model, knowing which keywords align with their product roadmap, evaluating brand voice in content. That's why you review and customize recommendations before sending to clients.
### How much can agencies save by automating SEO audits?
Typical agency audit pricing: $3,000 to $10,000 per audit. Manual time required: 28-42 hours. Automated audit time: 2-4 hours of analyst oversight. If you bill audits at $150/hour, that's $4,200 to $6,300 in labor cost per audit. Automation drops that to $300-$600. For agencies running 10 audits per month, that's $39,000 to $57,000 in monthly labor savings. Tool costs run $200-$600/month. Net monthly savings: $38,000 to $56,000.
### Do I need coding skills to set up automated audits?
No coding required if you use platforms like Duet that handle integrations. You connect API keys, describe what you need, and the platform orchestrates everything. If you're building custom automation with Python or Node.js, you'll need basic scripting skills to call APIs and format reports. Most marketing teams use no-code or low-code platforms. Technical teams build custom setups for more control and cheaper long-term costs.
### How often should I run automated audits for clients?
Monthly audits work for most clients. That cadence catches issues before they compound and tracks progress on implemented recommendations. Quarterly audits make sense for smaller clients or stable sites with fewer changes. Weekly or bi-weekly audits only make sense for large ecommerce sites or publishers making daily content updates. The key advantage of automation: frequency doesn't increase your workload. Monthly vs. quarterly costs the same in analyst time. Choose frequency based on client needs, not your capacity.
### Can I white-label automated SEO reports?
Yes. Most PDF generation tools let you customize branding: logos, color schemes, fonts, footer text. The AI writes analysis in your agency's voice if you provide style guidelines. Clients see your branding, not the underlying tool stack. Some agencies add a disclaimer: "This audit uses industry-standard SEO tools and AI-assisted analysis." Others don't mention the automation at all. From the client perspective, they receive a professional report with actionable recommendations. How you produced it is your business.
### What happens if the AI flags issues that aren't actually problems?
AI occasionally flags false positives: a "broken link" that's actually a JavaScript-rendered element, or "thin content" on a landing page that's intentionally concise. That's why you review findings before sending to clients. Skim through flagged issues, verify the major ones, remove obvious false positives. This review takes 15-20 minutes. Manual audits have the same problem—junior analysts flag things that aren't issues. The fix is the same: senior review before delivery. Automation doesn't eliminate the need for expertise. It eliminates the need for manual data collection.
---
Source: https://duet.so/blog/how-to-generate-branded-social-media-content-at-scale
# Generate Branded Social Media Content In An Hour
*Stop posting one-off. Generate weeks of on-brand social content in an hour using AI. Consistent voice, zero burnout.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 13 min read.
Social media content is one of those things that is easy to do badly and surprisingly hard to do consistently well.
Most teams either post sporadically when someone finds the time, or they hire a social media manager whose entire job becomes a content treadmill. Neither scales, and neither compounds into anything meaningful.
AI-generated social content, done right, breaks both of those patterns.
You can batch-create a month of on-brand, platform-optimised content in a single session, maintain consistent voice across LinkedIn, X, and Instagram, and free up your team to focus on strategy rather than sentence construction.
This guide covers how to pull that off without producing content that looks like every other brand using the same AI prompts.
Quick Summary
This guide shows how to generate branded social media content at scale using AI. Building a system that produces on-brand posts, captions, and visuals consistently across platforms without manual content creation for every piece.
Questions this page answers
- How to generate social media content with AI at scale
- Best AI tools for branded social media content
- How to automate social media content creation
- Can AI maintain brand voice in social media posts?
- How to build an AI social media content system?
## Why Most Agencies Can't Scale Social Media Content
Every client needs 15-30 posts per month. Each post must match their brand colors, fonts, tone, and visual style.
Manual production looks like this:
- Designer references brand guidelines PDF
- Copies hex codes into Canva or Figma
- Writes copy in client's voice
- Exports image at correct dimensions
- Repeats for every platform and format
At 20 minutes per post, one designer handles 4-5 clients maximum. Revenue caps at designer capacity.
The constraint isn't creativity. It's repetitive formatting work that follows documented rules.
## How AI Content Creation Tools Extract Brand Identity Automatically
Modern AI tools for social media content creation pull brand parameters directly from a client's live website. No manual style guide required.
What gets extracted:
Tools like Firecrawl or Jina Reader return clean markdown plus metadata. Feed that into an AI ad copy generator with instructions like "write 7 Instagram captions in the same tone as the About page."
The AI matches sentence length, punctuation style, emoji usage, and vocabulary complexity. Output feels human-written because it's trained on the client's actual published content.
## Step-by-Step: Generating a Week of Branded Posts in 15 Minutes
This workflow produces 7 posts (copy + images) for one client on one platform.
1. Extract brand identity (2 minutes)
Run a web scraper on the client's homepage and About page:
```bash
curl -X POST https://api.firecrawl.dev/v1/scrape \
-H "Authorization: Bearer YOUR_KEY" \
-d '{"url": "https://clientsite.com", "formats": ["markdown","screenshot"]}'
```
Save the markdown output and screenshot. The markdown contains tone samples; the screenshot captures visual style.
2. Generate post copy (3 minutes)
Prompt an AI content creation tool with:
- Brand voice sample (from extracted markdown)
- Post topics (product launches, tips, testimonials)
- Platform constraints (Instagram: 2,200 char max, first 125 chars visible)
Example prompt:
```plaintext
Generate 7 Instagram captions for a sustainable activewear brand.
Tone: Conversational, inclusive, eco-focused. Match this style:
[paste 200 words from About page]
Topics:
- New legging launch
- Fabric care tips
- Customer spotlight
- Yoga challenge announcement
- Behind-the-scenes production
- Sustainability stat
- Weekend motivation
Keep first sentence under 125 characters for preview.
Include 5-8 hashtags per post.
```
Most AI ad copy generators return all 7 captions in 30 seconds. Review for accuracy and brand safety.
3. Generate branded images (8 minutes)
Use image generation tools with brand color codes and style descriptors. If the client uses minimalist photography with sage green overlays:
```plaintext
Product photo of sustainable activewear leggings,
minimalist composition, natural lighting,
color palette: sage green (#A8BBA0), cream (#F5F1E8),
Instagram square 1080x1080
```
Generate one image per post. Current tools (Midjourney, Stable Diffusion, Flux) take 30-60 seconds per image.
For faster turnarounds, create a base template with the client's logo and color scheme, then swap in AI-generated product shots or lifestyle images.
4. Review and schedule (2 minutes)
Spot-check that colors match brand guidelines. Confirm hashtags are relevant and trending. Load into a scheduling tool like Buffer or Later.
Total time: 15 minutes for 7 posts. One person can serve 20+ clients per day.
## Maintaining Brand Voice Consistency Across AI-Generated Content
AI-generated copy drifts over time as you reuse generic prompts. Lock in consistency with these techniques:
Build a voice profile per client
After extracting tone samples, create a 300-word "voice document" that defines:
- Sentence length (short/varied/long)
- Punctuation style (em dashes, ellipses, exclamation points)
- Vocabulary (industry jargon, slang, formal)
- Perspective (first-person plural "we," second-person "you")
- Personality (playful, authoritative, warm)
Save this as a reusable prompt prefix. Every content request starts with "Use this voice:" + the profile.
Use few-shot examples
Include 3-5 real posts the client has published. AI tools for social media content creation learn faster from examples than from abstract descriptions.
Format:
```plaintext
Here are 3 approved Instagram captions from [Client]:
[Post 1]
[Post 2]
[Post 3]
Generate 5 new captions in the same style on these topics:
[Topic list]
```
Match rates improve from 70% to 90%+ with few-shot prompting.
A/B test against human-written baselines
Once per month, have a human copywriter write 2 posts. Mix them into AI-generated content. Track which performs better (engagement, click-through, conversions).
If AI consistently underperforms, update your voice profile or switch to a better model. GPT-4 and Claude 3 Opus handle brand voice better than older or smaller models.
## Creating Short Branded Video Clips from Text Prompts
Video posts get 2-3x the engagement of static images on most platforms. Agencies avoid video because production takes hours.
AI video tools now generate 5-15 second clips from text descriptions. No filming or editing required.
Text-to-video workflow:
1. Write a 1-sentence scene description
1. Include brand colors and visual style
1. Generate video in target aspect ratio
1. Add voiceover using text-to-speech
1. Overlay logo and captions
Example for a skincare brand:
```plaintext
Scene: Close-up of hands applying cream,
soft natural lighting,
color grade: warm beige and cream tones,
9:16 vertical for Instagram Reels
```
Tools like Runway, Pika, or Kling output a 5-second clip in 2-3 minutes. Add a 10-second voiceover using ElevenLabs or Play.ht (choose a voice that matches brand personality).
Render final video with burned-in captions for accessibility. Platforms auto-play videos on mute, so captions increase watch time by 40%.
Video content batching:
Generate 4 video clips per client per month. Reuse footage by changing voiceover and captions. One product demo becomes:
- Feature highlight reel
- Customer testimonial quote
- How-to tutorial
- Behind-the-scenes story
Production time: 30 minutes for 4 variations instead of 6 hours of traditional video editing.
## Real-World Example: Branded Content Pipeline with Persistent AI Workflows
A growth marketing agency manages social media for 15 e-commerce brands. Each client needs 20 posts per month across Instagram, Facebook, and LinkedIn.
Previous workflow:
- 2 designers working full-time
- 6 hours per client per month
- 90 hours total monthly design time
- Frequent revisions for off-brand content
New AI-powered workflow:
Brand extraction: One-time setup per client. Scrape their website to pull colors, fonts, logos, and 500 words of voice samples. Store in a structured template.
Content generation: Weekly batch process. AI generates 5 posts per platform using stored brand parameters. Images created with brand color overlays and product photos.
Video creation: Monthly batch. Text-to-speech generates voiceovers in brand-appropriate tone. Video generator creates 15-second clips with brand colors and logo watermarks.
Persistent automation: The workflow runs on a cloud server that stays online 24/7. Clients request content via a chat interface; the system extracts brand data, generates assets, and delivers a preview in under 20 minutes.
Results after 3 months:
- Design time reduced from 90 hours to 12 hours per month
- Client capacity increased from 15 to 40 brands
- Revision requests dropped by 60% (better brand matching)
- Revenue per employee doubled
Tools used: Firecrawl for brand extraction, GPT-4 for copy generation, Flux for image creation, ElevenLabs for text-to-speech. The agency built the workflow using an AI collaboration platform that keeps context and connections available across sessions.
The platform runs at duet.so and handles the integration between scraping, generation, and media tools. Instead of manually copying brand parameters between five different services, the system maintains brand profiles and applies them automatically to every content request.
## Platform-Specific Content Requirements
Different social platforms demand different formats. AI tools for social media content creation must adapt to these constraints:
Configure your AI content creation tools to output correct dimensions and character counts automatically. Most image generators accept aspect ratio parameters: --ar 9:16 for vertical, --ar 1:1 for square.
For video, specify duration in your prompt: "5-second product reveal" or "15-second tutorial intro."
## Pricing and ROI for Agency Social Media Automation
Tool costs per month:
- Web scraping API: $50-200 (Firecrawl, Jina)
- AI text generation: $50-200 (OpenAI, Anthropic)
- AI image generation: $30-100 (Midjourney, Replicate)
- Text-to-speech: $30-100 (ElevenLabs, Play.ht)
- Video generation: $50-200 (Runway, Pika)
Total: $210-800/month depending on volume and quality tier.
Time savings:
- Old process: 6 hours per client per month
- New process: 45 minutes per client per month
- Savings: 5.25 hours per client
At $75/hour blended designer rate: $393.75 saved per client per month.
Break-even point: 1 client (tools pay for themselves immediately).
Revenue scaling:
If one designer previously handled 5 clients (30 hours/month design time), automation lets them handle 40 clients (30 hours/month at 45 min each).
At $500/month per client for social media management:
- Old capacity: $2,500/month revenue per designer
- New capacity: $20,000/month revenue per designer
- Increase: 8x
Most agencies price social media packages at $500-2,000/month depending on post volume and platforms. Automation maintains quality while increasing profit margin from 30% to 70%+.
## Common Pitfalls and How to Avoid Them
AI-generated content looks generic
Problem: Using the same prompt for every client produces samey output.
Solution: Extract brand voice samples for each client. Include 3-5 real posts in your prompt. Update voice profiles quarterly as brand evolves.
Colors don't match brand guidelines
Problem: AI image generators interpret color names loosely. "Sage green" varies widely.
Solution: Always specify hex codes. "Color palette: #A8BBA0, #F5F1E8" instead of "sage green and cream."
Videos look amateur despite AI generation
Problem: AI video tools struggle with complex motion and camera work.
Solution: Use simple, single-shot scenes. Close-ups of products, flat-lay compositions, slow pans. Avoid multi-character scenes or rapid movement.
Client pushback on AI-generated content
Problem: Some clients worry AI content lacks authenticity or violates platform policies.
Solution: Present AI content as drafts requiring human review. Emphasize that brand voice and creative direction come from their existing materials. Most platforms allow AI-generated content as long as it's disclosed and not deceptive.
Content quality degrades over time
Problem: Reusing the same prompts leads to repetitive output.
Solution: Rotate through different content themes monthly. Update few-shot examples every quarter. A/B test AI content against human-written baselines.
## Frequently Asked Questions
### Can AI tools really match a specific brand's visual style consistently?
Yes, when given precise parameters. Provide hex color codes, font names, and reference images. Modern AI ad copy generators and image models learn brand style from 3-5 examples. Consistency improves with few-shot prompting: show the AI 3 approved posts, then ask for 5 more in the same style. Match rates exceed 85% for visual elements and 90% for written tone when using GPT-4 or Claude 3 Opus with proper prompting.
### How do you prevent AI-generated social content from sounding robotic?
Extract 300-500 words of existing client content (About page, blog posts, past social media). Feed that to the AI as a voice sample with instructions to match the tone. Include specific directives: "Use short sentences," "Include em dashes," "Write in first-person plural." Use few-shot examples showing 3-5 real posts. Avoid generic prompts like "professional tone" or "friendly voice." Specificity prevents robotic output.
### What's the fastest way to generate branded images for social media posts?
Use an image generation API with saved brand parameters. Create a template prompt: "Product photo, minimalist composition, brand colors #HEX1 and #HEX2, 1080x1080." Swap in the product name and generate. Most tools return images in 30-60 seconds. For faster results, generate base templates once per client (branded backgrounds, layouts), then overlay AI-generated product shots or text using a design automation tool like Bannerbear or Placid.
### Do social media platforms allow AI-generated content in their feeds?
All major platforms permit AI-generated content as of 2026. Instagram, Facebook, LinkedIn, and TikTok have no blanket bans on AI content. YouTube requires disclosure for realistic AI-generated videos. Twitter/X allows AI content without restriction. The key requirement across platforms: don't mislead users. Disclose AI involvement if the content depicts people or events that didn't occur. Product images, illustrations, and generic stock-style photos don't require disclosure.
### How many clients can one person manage using AI content tools?
One person can produce branded content for 30-40 clients per month using AI workflows. At 45 minutes per client (15 minutes weekly for content generation, 15 minutes monthly for strategy review), that's 20-30 hours of production time. The limiting factor becomes client communication and strategy, not asset creation. Agencies scaling past 40 clients hire account managers, not designers.
### Which AI content creation tools work best for social media agencies?
For copy: GPT-4 or Claude 3 Opus via API. Both handle brand voice matching and platform-specific constraints well. For images: Midjourney for quality (manual workflow), Flux or Stable Diffusion XL via API for automation. For video: Runway or Pika for short clips; ElevenLabs or Play.ht for voiceovers. For brand extraction: Firecrawl or Jina Reader. For workflow orchestration: use an AI collaboration platform that keeps brand profiles and context persistent across sessions.
### How do you scale video content creation without hiring video editors?
Generate simple, single-shot video clips using AI video tools. Avoid complex scenes with multiple characters or camera movements. Focus on product close-ups, text animations, and slow pans. Use text-to-speech for voiceovers instead of recording audio. Create one master video per client per month, then produce 3-4 variations by changing voiceover and captions. Batch-generate videos weekly: 4 clients 4 videos = 16 videos in 2-3 hours instead of 30+ hours of traditional editing.
---
Source: https://duet.so/blog/how-to-host-openclaw-in-the-cloud
# How to Host OpenClaw in the Cloud (Always On)
*Deploy OpenClaw on a VPS or managed platform for 24/7 AI agent operation with Docker, security best practices, and cost analysis.*
By David. Published 2026-03-01, updated 2026-05-08. 12 min read.
# How to Host OpenClaw in the Cloud
Quick Summary
This guide covers how to host OpenClaw in the cloud so it runs 24/7, no local machine required. You'll get a persistent, always-on OpenClaw instance accessible from anywhere, without managing your own VPS or infrastructure.
Questions this page answers
- How to host OpenClaw in the cloud
- Can you run OpenClaw on a cloud server?
- How to make OpenClaw always-on
- Best cloud hosting for OpenClaw
- How to run OpenClaw without a local machine?
OpenClaw is an open-source autonomous AI agent platform with over 140,000 GitHub stars.
It executes complex tasks by breaking them into steps, writing code, running commands, and iterating until completion.
Unlike traditional AI assistants that answer questions, OpenClaw takes action.
It builds apps, fixes bugs, analyzes data, and automates workflows without constant supervision.
The platform runs locally by default. When your laptop sleeps or closes, OpenClaw stops.
For long-running tasks or team collaboration, you need cloud hosting.
## Why Self-Hosting OpenClaw Requires a Cloud Server
Local OpenClaw deployment has limitations:
- Stops when your computer sleeps. Tasks fail mid-execution.
- No remote access. You can't check progress from another device.
- Single-user only. Team members can't share agents or workflows.
- Resource intensive. Running AI models drains laptop battery and CPU.
Cloud hosting solves these problems. Your agent runs 24/7 on dedicated infrastructure, accessible from anywhere, with shared team access.
## Cloud Hosting Options for OpenClaw
VPS, Docker, and Managed Platforms
You have two paths: self-host on a VPS or use a managed platform.
Self-hosting gives you full control. You configure the server, manage updates, handle security, and pay only for compute resources.
Managed platforms handle infrastructure, security, and updates automatically. You focus on using the agent, not maintaining servers.
## How to Self-Host OpenClaw on a VPS
Self-hosting requires a Linux server, Docker, and basic command-line skills. Here's the complete setup.
### Choose a VPS Provider
Select a provider based on pricing and location:
| Provider | Monthly Cost | RAM | CPU Cores | Storage |
| -------------------- | ------------ | --- | --------- | -------- |
| Hetzner CAX11 | $5 | 4GB | 2 | 40GB SSD |
| DigitalOcean Basic | $6 | 1GB | 1 | 25GB SSD |
| DigitalOcean Regular | $12 | 2GB | 1 | 50GB SSD |
| AWS Lightsail | $10 | 2GB | 1 | 60GB SSD |
| Linode Shared | $12 | 2GB | 1 | 50GB SSD |
OpenClaw requires minimum 4GB RAM and 2 CPU cores for stable operation. The $5 Hetzner option is the most cost-effective for full performance.
For lighter usage, a 2GB instance ($10-12/mo) works but may timeout on large tasks.
### Provision and Access Your Server
Create a new instance with Ubuntu 22.04 LTS. Add your SSH public key during setup.
Connect to your server:
```bash
ssh root@YOUR_SERVER_IP
```
Update system packages:
```bash
apt update && apt upgrade -y
```
### Install Docker
Install Docker Engine:
```bash
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
```
Verify installation:
```bash
docker --version
```
Enable Docker to start on boot:
```bash
systemctl enable docker
```
### Configure Environment Variables
Create a directory for OpenClaw:
```bash
mkdir -p /opt/openclaw
cd /opt/openclaw
```
Create an environment file:
```bash
nano .env
```
Add your configuration:
```plaintext
ANTHROPIC_API_KEY=your_anthropic_key
OPENAI_API_KEY=your_openai_key
WORKSPACE_DIR=/workspace
PORT=3000
```
Save and exit (Ctrl+X, Y, Enter).
### Run OpenClaw with Docker
Pull the latest OpenClaw image:
```bash
docker pull openclaw/openclaw:latest
```
Run the container:
```bash
docker run -d \
--name openclaw \
--restart unless-stopped \
-p 3000:3000 \
-v /opt/openclaw/workspace:/workspace \
--env-file /opt/openclaw/.env \
openclaw/openclaw:latest
```
Check container status:
```bash
docker ps
```
View logs:
```bash
docker logs -f openclaw
```
### Configure Firewall and Security
Set up UFW firewall:
```bash
ufw allow OpenSSH
ufw allow 3000/tcp
ufw enable
```
Disable password authentication:
```bash
nano /etc/ssh/sshd_config
```
Set PasswordAuthentication no. Restart SSH:
```bash
systemctl restart sshd
```
### Set Up SSL with Nginx (Optional)
For HTTPS access, install Nginx and Certbot:
```bash
apt install nginx certbot python3-certbot-nginx -y
```
Configure Nginx reverse proxy:
```bash
nano /etc/nginx/sites-available/openclaw
```
Add configuration:
```plaintext
server {
listen 80;
server_name your-domain.com;
location / {
proxy_pass http://localhost:3000;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_cache_bypass $http_upgrade;
}
}
```
Enable site and get SSL certificate:
```bash
ln -s /etc/nginx/sites-available/openclaw /etc/nginx/sites-enabled/
certbot --nginx -d your-domain.com
```
### Monitor and Update
Check OpenClaw health:
```bash
docker stats openclaw
```
Update to latest version:
```bash
docker pull openclaw/openclaw:latest
docker stop openclaw
docker rm openclaw
docker run -d \
--name openclaw \
--restart unless-stopped \
-p 3000:3000 \
-v /opt/openclaw/workspace:/workspace \
--env-file /opt/openclaw/.env \
openclaw/openclaw:latest
```
Set up automatic backups of /opt/openclaw/workspace:
```bash
crontab -e
```
Add daily backup:
```plaintext
0 2 * * * tar -czf /backup/openclaw-$(date +\%Y\%m\%d).tar.gz /opt/openclaw/workspace
```
## OpenClaw Cloud Security
Risks You Need to Know Before Deploying
Exposing an AI agent to the internet creates attack surface.
### API Key Exposure
OpenClaw stores API keys in environment variables. If an attacker gains container access, they can extract keys and rack up charges on your accounts.
Mitigation:
- Use read-only API keys where possible
- Set spending limits on OpenAI/Anthropic accounts
- Rotate keys monthly
- Never commit .env files to version control
### Code Execution Vulnerabilities
OpenClaw executes arbitrary code. Malicious prompts could exploit this to run unintended commands.
CVE-2024-47068 affected similar AI agent platforms in October 2024, allowing remote code execution through prompt injection.
Mitigation:
- Run OpenClaw in isolated containers with limited filesystem access
- Use non-root users inside containers
- Implement network segmentation
- Monitor logs for suspicious activity
### Skill and Plugin Risks
OpenClaw supports custom skills. Unverified skills can contain malicious code.
Mitigation:
- Review skill source code before installation
- Use only official or vetted community skills
- Run skills in sandboxed environments
- Maintain an allowlist of approved skills
## Self-Hosted OpenClaw vs. Managed AI Agent Platforms
Managed platforms eliminate infrastructure maintenance but reduce flexibility.
### What You Get with Managed Platforms
Managed AI agent platforms handle:
- Server provisioning and scaling
- Security patches and updates
- SSL certificates and domain configuration
- Team collaboration features
- Built-in authentication and access control
- Monitoring and alerting
You access the agent through a web interface without touching Docker or Linux commands.
### Cost Comparison
| Hosting Type | Monthly Cost | Setup Time | Maintenance | Security |
| ---------------- | ------------ | ---------- | ----------- | --------------------- |
| VPS Self-Host | $5-20 | 1-2 hours | Ongoing | Your responsibility |
| Managed Platform | $20-100 | 5 minutes | None | Handled automatically |
Self-hosting is cheaper for single users comfortable with server administration. Managed platforms save time and reduce security risk for teams.
### When to Choose Self-Hosting
Choose self-hosting if you:
- Want maximum control over infrastructure
- Have DevOps expertise or time to learn
- Need custom configurations not supported by platforms
- Run sensitive workloads that can't use shared infrastructure
### When to Choose Managed Hosting
Choose managed platforms if you:
- Want to start immediately without setup
- Lack server administration experience
- Need team collaboration features
- Prefer predictable costs without surprise server bills
## Best Managed Alternatives to Self-Hosting OpenClaw
If you like OpenClaw's autonomous capabilities but want cloud infrastructure handled for you, several platforms offer similar functionality with better team features.
Duet provides an always-on AI agent that runs in the cloud with no server setup required. Unlike self-hosted OpenClaw, you get team workspaces, built-in security, reusable instructions in Files, durable facts and sources in Train, and managed Integrations. Your agents run continuously on managed infrastructure, so you do not have to operate the server or maintain Docker yourself.
The platform includes collaboration features OpenClaw lacks: durable shared sessions, trained workspace memory, role-based access, and shared files and apps. Team members can assign work to the same persistent AI coworker and follow its session events while long-running tasks continue in the cloud.
For teams moving from local development to production AI workflows, Duet bridges the gap between DIY open source tools and fully managed infrastructure. Learn more at duet.so.
## How to Migrate OpenClaw from Local to Cloud Hosting
Moving an existing OpenClaw setup to the cloud preserves your configuration and conversation history.
### Export Local Data
On your local machine, locate the OpenClaw workspace directory. Default locations:
- Linux/macOS: ~/.openclaw/workspace
- Windows: C:\Users\YourName\.openclaw\workspace
Archive the workspace:
```bash
tar -czf openclaw-backup.tar.gz ~/.openclaw/workspace
```
### Transfer to VPS
Copy the archive to your server:
```bash
scp openclaw-backup.tar.gz root@YOUR_SERVER_IP:/opt/openclaw/
```
SSH into the server and extract:
```bash
cd /opt/openclaw
tar -xzf openclaw-backup.tar.gz
```
### Update Configuration
Copy environment variables from local .env to server /opt/openclaw/.env.
Verify API keys work by testing with curl:
```bash
curl https://api.anthropic.com/v1/models \
-H "x-api-key: $ANTHROPIC_API_KEY"
```
### Start Cloud Instance
Run Docker container with migrated workspace:
```bash
docker run -d \
--name openclaw \
--restart unless-stopped \
-p 3000:3000 \
-v /opt/openclaw/workspace:/workspace \
--env-file /opt/openclaw/.env \
openclaw/openclaw:latest
```
Access via http://YOURSERVERIP:3000 and verify conversation history loaded.
## OpenClaw Cloud Maintenance
What You Need to Keep It Running
Cloud-hosted OpenClaw requires regular maintenance.
### Weekly Tasks
- Review Docker logs for errors: docker logs openclaw --tail 100
- Check disk usage: df -h
- Monitor API spending in Anthropic/OpenAI dashboards
### Monthly Tasks
- Update OpenClaw to latest version (see Step 8 above)
- Rotate API keys
- Review and clean old workspace files
- Check security advisories for dependencies
### Quarterly Tasks
- Audit installed skills for updates
- Review firewall rules
- Test backup restoration process
- Evaluate server sizing (upgrade if hitting resource limits)
### Automation
Reduce manual work with systemd timers or cron jobs:
```bash
# /etc/cron.weekly/openclaw-update
#!/bin/bash
docker pull openclaw/openclaw:latest
docker stop openclaw
docker rm openclaw
docker run -d --name openclaw --restart unless-stopped -p 3000:3000 \
-v /opt/openclaw/workspace:/workspace \
--env-file /opt/openclaw/.env \
openclaw/openclaw:latest
```
## OpenClaw High Availability Setup
Load Balancing and Failover
Single-server deployments fail when the server goes down. High availability requires redundancy.
### Load Balancer Setup
Deploy multiple OpenClaw instances behind a load balancer:
1. Provision 2-3 identical VPS instances
1. Set up shared storage (NFS or S3) for workspace directory
1. Configure Nginx or Traefik as load balancer
1. Point DNS to load balancer IP
Cost increases 2-3x but eliminates single point of failure.
### Database Replication
If OpenClaw stores state in a database, configure primary-replica replication:
```bash
# On primary server
docker run -d \
--name postgres-primary \
-e POSTGRES_PASSWORD=secure_password \
-e POSTGRES_USER=openclaw \
-p 5432:5432 \
postgres:15
```
Configure replicas to stream from primary. Update OpenClaw config to use read replicas for queries.
### Health Monitoring
Set up uptime monitoring with UptimeRobot or Healthchecks.io:
1. Create HTTP health check endpoint
1. Configure alert if endpoint returns non-200 status
1. Set notification to email/Slack on failure
Most teams don't need HA for development use cases. Production workflows justify the added complexity.
## Final Thoughts
Hosting OpenClaw in the cloud transforms a local development tool into a 24/7 autonomous agent. Self-hosting on a VPS costs $5-20/month and gives you full control, but requires ongoing security maintenance and server administration.
For teams or those who want to skip infrastructure management, managed platforms handle deployment, security, and scaling automatically. The choice depends on your technical comfort level, budget, and collaboration requirements.
Start with a basic VPS deployment to understand OpenClaw's cloud hosting needs. As usage grows, migrate to high-availability setups or managed platforms that offer better team features and reduced operational overhead.
## Frequently Asked Questions
### How much does it cost to host OpenClaw in the cloud?
Hosting OpenClaw on a VPS costs $5-20/month for the server plus API usage fees. A Hetzner CAX11 ($5/mo) with 4GB RAM handles most workloads. Add $10-50/mo for Anthropic/OpenAI API calls depending on usage. SSL certificates via Let's Encrypt are free.
### Can I run OpenClaw on AWS free tier?
AWS free tier includes 750 hours of t2.micro instances with 1GB RAM. This is insufficient for OpenClaw, which requires minimum 4GB RAM. You'll need a t3.medium ($30/mo) or t3.large ($60/mo) instance for reliable performance.
### What's the easiest way to deploy OpenClaw?
The easiest deployment method is using Docker on a managed VPS. Providers like DigitalOcean and Hetzner offer one-click Docker images. After provisioning, run a single docker run command with your API keys. Setup takes 15-30 minutes including SSL configuration.
### How do I secure API keys on a cloud server?
Store API keys in environment files outside the container with restricted permissions: chmod 600 /opt/openclaw/.env. Use read-only API keys where possible. Rotate keys monthly. Enable audit logging to detect unauthorized access. Consider using secret management tools like Vault for production deployments.
### Does OpenClaw work with custom AI models?
Yes, OpenClaw supports custom models through OpenAI-compatible API endpoints. Configure the OPENAIAPIBASE environment variable to point to your model provider (e.g., Ollama, LocalAI, or self-hosted LLaMA). Performance depends on model capability and hosting infrastructure.
### Can multiple people use the same OpenClaw instance?
OpenClaw's default setup is single-user. Multiple people accessing the same instance share conversation history and workspace files, which creates confusion. For team use, deploy separate instances per user or use a managed platform with built-in multi-user support.
### What happens if my server crashes?
If you configured, restart unless-stopped, Docker automatically restarts the OpenClaw container when the server reboots. In-progress tasks may fail and require manual restart. Implement health monitoring and alerting to detect outages quickly. Regular workspace backups prevent data loss.
---
Source: https://duet.so/blog/how-to-run-claude-code-in-the-cloud
# Run Claude Code in the Cloud 24/7 (No Laptop Needed)
*Run Claude Code on a persistent cloud server — sessions stay alive for days, work from your phone, no laptop required. Full setup in 5 minutes.*
By Duet Team. Published 2026-03-01, updated 2026-05-07. 15 min read.
# How to Run Claude Code in the Cloud Without Installing Anything
You can run Claude Code on a cloud-hosted Linux server instead of installing it locally. This gives you persistent coding sessions that run for hours or days without draining your laptop battery, access from any device, and the ability to share the same AI agent with your entire team. Cloud-hosted Claude Code eliminates the Node.js setup, keeps sessions alive when you close your laptop, and works exactly like the CLI but in a remote environment. For the operator playbook of running a company this way, see [Duet AI for Founders: Founder Mode as an Operating System](/guides/duet-ai-for-founders).
**Want it running now without the setup?** [Run Claude Code in the cloud on Duet →](https://app.duet.so/sign-in?from=blog-cc-cloud-top) Persistent sandbox, resume from any device, nothing to install.
> **If you already use Duet:** Start a durable session and assign the coding task. The agent runs on the workspace's persistent cloud VM, so the session history, files, and resulting app remain available after your laptop closes.
## Why Your Claude Code Cloud Environment Matters
A Claude Code cloud environment is a remote Linux server that runs the Claude Code CLI continuously. Instead of running the agent on your laptop and losing context every time you close the lid, a hosted Claude Code environment keeps the session alive on a server you connect to from anywhere. The cloud environment persists your git state, agent memory, and MCP integrations between sessions, so the agent picks up exactly where it left off.
Teams adopt a Claude Code cloud setup for three reasons: persistence (sessions survive browser closes and laptop reboots), access (any device, any location), and collaboration (multiple team members can work with the same agent through shared session history and files). If you're evaluating whether to move your Claude Code workflow off your local machine, the rest of this guide walks through exactly how to set it up.
## Why Running Claude Code Locally Has Limitations
The standard Claude Code CLI runs on your local machine and stops when you close your laptop or lose battery. Every session is tied to your terminal window. When your computer sleeps, the agent stops working.
Here are the core limitations:
- **Battery drain:** Long coding sessions consume significant power
- **Session interruption:** Closing your laptop kills the agent mid-task
- **Single-device access:** Can't switch between your laptop, tablet, or phone
- **No team access:** Other team members can't see or interact with the agent's work
- **Local resource constraints:** Large repos and concurrent operations slow down your machine
- **No persistence:** Agent memory and context reset when you restart
If you're running multi-hour refactoring sessions or want your agent to keep working overnight, local execution doesn't work. You need a persistent server.
## What Cloud-Hosted Claude Code Actually Means
Cloud-hosted Claude Code is the same CLI running on a remote Linux server instead of your laptop. The server stays on 24/7, maintains session state, and multiple users can connect to the same instance.
The technical setup:
| Component | Local Claude Code | Cloud-Hosted Claude Code |
| ------------------- | ---------------------------- | --------------------------------- |
| Runtime environment | Your macOS/Windows laptop | Linux server (Ubuntu 22.04+) |
| Session persistence | Ends when you close terminal | Runs until you explicitly stop it |
| Access method | Terminal on your machine | Web interface or SSH |
| Resource limits | Your laptop's CPU/RAM | Server specs (configurable) |
| Team collaboration | Not possible | Multiple users can connect |
| Cost | API usage only | API usage + server hosting |
The cloud server has Node.js pre-installed, the Claude Code CLI configured, and a web UI for interaction. Your GitHub repos clone to the server, and the agent makes commits/PRs from there. If you're weighing Claude Code against other CLI agents, see [Codex vs Claude Code: features, pricing, and benchmarks compared](/blog/codex-vs-claude-code).
## Claude Code Cloud Setup in 5 Minutes
If you want a hosted Claude Code instance running right now, the fastest path is a managed platform:
1. Create an account on [Duet](/) (or your preferred cloud host)
2. Connect your GitHub account and add your Anthropic API key
3. Start a session with your first task
That's it. The platform provisions a persistent Linux server with Claude Code pre-installed, your repos cloned, and MCP integrations ready. No Node.js install, no SSH, no tmux. You are not installing Claude Code on top of Duet. Duet is Claude Code running in the cloud. Your setup is live and the agent keeps working even after you close the browser.
Weighing a managed platform against rolling your own? See [Duet vs OpenClaw: managed vs self-hosted AI agents](/guides/duet-vs-openclaw). For self-hosted options (AWS, DigitalOcean) or a deeper walkthrough of each step, keep reading.
## Step-by-Step: Setting Up Cloud-Hosted Claude Code
Here's how to get Claude Code running in the cloud without touching your local terminal.
### Option 1: Using a Managed Platform
The fastest way is to use a platform that pre-configures everything. [Duet](/) provides cloud-hosted Claude Code as part of its core product.
**Sign-up flow:**
1. Go to duet.so and create an account
2. Connect your GitHub account (the platform needs repo access)
3. Add your Anthropic API key in settings
4. Start a new session and assign the task
The platform provisions a persistent Linux sandbox with Claude Code pre-installed. The agent has access to your repos and can open PRs directly.
**What you get:**
- Claude Code running natively, not a wrapper or plugin. Duet is Claude Code in the cloud
- Web-based interface (no terminal needed)
- Persistent sessions that survive browser closes
- Built-in memory system across conversations
- Team access (multiple people can interact with the same agent)
- MCP integration support for Linear, GitHub, Notion, and 500+ other tools
The server persists indefinitely. You can start a task, close your browser, and come back hours later to see the agent's progress.
### Option 2: Self-Hosted on AWS/DigitalOcean
If you want to manage the infrastructure yourself, spin up a Linux server and install Claude Code manually.
**Prerequisites:**
- Ubuntu 22.04 or later
- 4GB+ RAM recommended
- Node.js 18+
- Git installed
**Installation steps:**
1. Launch an EC2 instance or DigitalOcean droplet (Ubuntu 22.04)
2. SSH into the server
3. Install Node.js: `curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash - && sudo apt-get install -y nodejs`
4. Install Claude Code CLI: `npm install -g @anthropic-ai/claude-code`
5. Set your Anthropic API key: `export ANTHROPIC_API_KEY=your_key_here`
6. Clone your repo: `git clone https://github.com/your-org/your-repo.git`
7. Start Claude Code: `cd your-repo && claude-code`
To keep sessions persistent, run Claude Code in a `tmux` or `screen` session:
```bash
tmux new -s coding
claude-code
# Detach with Ctrl+B, then D
# Reattach later with: tmux attach -t coding
```
The drawback: you're managing the server, security, updates, and tooling yourself. No web UI unless you build one.
## Connecting Your GitHub Repo to the Cloud Instance
Once your cloud server is running, you need to give it GitHub access.
**For managed platforms:**
The platform handles GitHub OAuth during sign-up. You authorize repo access once, and the agent can clone/commit/PR on your behalf.
**For self-hosted servers:**
Generate a GitHub personal access token with `repo` scope:
1. Go to GitHub Settings → Developer settings → Personal access tokens
2. Create a token with `repo` and `workflow` permissions
3. On your server, configure Git to use the token:
```bash
git config --global user.name "Your Name"
git config --global user.email "your@email.com"
git config --global credential.helper store
echo "https://YOUR_TOKEN@github.com" > ~/.git-credentials
```
Now when Claude Code runs `git push`, it authenticates automatically.
**Repo cloning:**
If your repo is private, make sure the token has access. Clone with HTTPS (not SSH unless you've set up keys):
```bash
git clone https://github.com/your-org/your-repo.git
```
The agent can now read files, create branches, commit changes, and open pull requests.
## Starting Your First Cloud Coding Session
With the server configured and GitHub connected, you can start a coding task.
**On a managed platform:**
Open the web UI, start a session in your project workspace, and assign the task:
```
@agent refactor the user authentication module to use JWT tokens instead of session cookies
```
The agent will:
1. Read the current auth code
2. Create a new git branch
3. Implement the JWT changes
4. Run tests (if configured)
5. Open a PR against your main branch
The session persists even if you close the browser. You can check back later, and the agent will still be working or have finished.
**On a self-hosted server:**
SSH into your server, attach to your tmux session, and run:
```bash
claude-code "refactor the user authentication module to use JWT tokens instead of session cookies"
```
Claude Code will execute the task and stay running in the tmux session. Detach and check back later.
## Setting Up MCP Integrations on Your Cloud Instance
The Model Context Protocol (MCP) lets Claude Code integrate with external tools like Linear, GitHub, Notion, and Slack. Setting up MCP on a cloud instance works the same as locally, but you configure it on the server.
**What MCP provides:**
- Read Linear issues and update their status
- Fetch GitHub PRs and review comments
- Query Notion databases
- Search Slack messages
- Access 500+ other integrations through managed connectors
For a deep dive on extending the agent with custom commands, SKILL.md files, and when to use MCP vs built-in tools, see [Claude Code Skills: the complete guide](/guides/claude-code-skills-complete-guide).
**Configuration on self-hosted servers:**
Create an MCP config file at `~/.claude/mcp.json`:
```json
{
"mcpServers": {
"linear": {
"command": "npx",
"args": ["-y", "@linear/mcp-server"],
"env": {
"LINEAR_API_KEY": "your_linear_api_key"
}
},
"github": {
"command": "npx",
"args": ["-y", "@github/mcp-server"],
"env": {
"GITHUB_TOKEN": "your_github_token"
}
}
}
}
```
Restart Claude Code, and the agent will have access to those integrations.
**On managed platforms:**
Platforms like Duet come with MCP pre-configured. You connect integrations through the web UI:
1. Go to Settings → Integrations
2. Click "Connect Linear" (or GitHub, Notion, etc.)
3. Authorize via OAuth
4. The agent immediately has access
In the session, you can say:
```
@agent check Linear for all P0 bugs assigned to me, then open a PR fixing the authentication issue
```
The agent queries Linear via MCP, identifies the issue, makes the code changes, and opens the PR—all in one cloud-hosted session.
## Running Multi-Hour Sessions Without Interruption
Cloud-hosted Claude Code excels at long-running tasks that would be impractical on a laptop.
**Example use cases:**
- **Large codebase refactoring:** Agent spends 6 hours renaming a core module across 200 files
- **Dependency upgrades:** Agent updates React 17 → 18, fixes breaking changes, runs full test suite
- **Database migration:** Agent writes migration scripts, tests them, updates all ORM models
- **Security audit:** Agent scans for vulnerabilities, patches them, and opens individual PRs for each fix
On a local machine, these tasks would drain your battery or force you to keep your laptop open and plugged in. On a cloud server, you start the task and walk away.
**How to monitor long sessions:**
On managed platforms, the web UI shows real-time progress. You'll see:
- Current file being edited
- Git branches created
- PRs opened
- Errors encountered
On self-hosted servers, check the tmux session:
```bash
tmux attach -t coding
```
You'll see the Claude Code terminal output showing its current task.
**Handling errors mid-session:**
If the agent hits an error (failing test, API rate limit, merge conflict), cloud sessions let you intervene without losing context. On a managed platform, you reply in the chat:
```
The test is failing because the mock data is outdated. Update the fixture in tests/mocks/user.json
```
The agent continues from where it left off. On a self-hosted server, you can SSH in, fix the issue manually, and resume:
```bash
# Attach to tmux
tmux attach -t coding
# Agent is waiting on a failed test
# Exit Claude Code (Ctrl+C)
# Fix the mock data
vim tests/mocks/user.json
# Restart Claude Code
claude-code "continue the refactoring"
```
The persistent environment means you don't lose git state, file changes, or agent context.
## Team Collaboration on a Shared Cloud Instance
One major advantage of cloud-hosted Claude Code is team access. Multiple people can interact with the same agent in the same session.
**How it works on managed platforms:**
Each project or repo gets a dedicated workspace. Everyone on your team can start or review sessions there, and the agent maintains context through shared files and durable session history.
Example workflow:
1. **Sarah (designer):** "@agent implement the new dashboard layout from Figma"
2. **Agent:** Creates a branch, builds the UI components, opens PR #247
3. **Tom (backend engineer):** "@agent the API endpoint for dashboard data is returning 404"
4. **Agent:** Debugs the backend, finds the missing route, opens PR #248
5. **Sarah:** "@agent merge PR #247 and deploy to staging"
6. **Agent:** Merges the PR and triggers the deployment
The agent remembers the entire conversation history. Tom doesn't need to re-explain what Sarah asked for. The cloud server maintains state across team members.
**On self-hosted servers:**
Team collaboration requires custom tooling. You could:
- Set up a shared tmux session (multiple users SSH in and attach)
- Build a web UI on top of the Claude Code CLI
- Use SSH multiplexing with shared git repos
The managed platform approach is far easier for most teams.
## Cost Comparison: Local vs. Cloud
Here's how the economics break down.
| Cost Factor | Local Claude Code | Cloud-Hosted (Managed) | Cloud-Hosted (Self-Hosted) |
| -------------- | ---------------------------- | ---------------------------- | ---------------------------- |
| Anthropic API | $15 per million input tokens | $15 per million input tokens | $15 per million input tokens |
| Server hosting | $0 | Included in platform fee | $20-100/month (AWS/DO) |
| Setup time | 30 minutes | 5 minutes | 2-4 hours |
| Maintenance | None | None | Ongoing (security, updates) |
| Team access | Not available | Included | Requires custom tooling |
For individual developers running occasional sessions, local is cheaper. For teams running persistent agents or multi-hour sessions, cloud-hosted is more practical.
A typical startup with 5 engineers might spend:
- **API costs:** $200-500/month (depending on usage)
- **Managed platform:** $50-200/user/month (if using Duet or similar)
- **Self-hosted server:** $50/month (single DigitalOcean droplet)
The managed platform cost includes the server, web UI, MCP integrations, and team collaboration. Self-hosted is cheaper but requires engineering time to maintain. For a full breakdown of Claude Code plan tiers beyond API costs, see [Claude Code pricing: Pro vs Max vs API explained](/blog/claude-code-pricing).
## FAQ
**I signed up for Duet. Do I still need to install Claude Code?**
No separate local installation is required for Duet's managed agent. Start a session and the task runs on the persistent workspace VM, with its files and event history available through the web app and API.
**Can I run Claude Code in the cloud without a credit card?**
Most managed platforms require payment info upfront because they provision server resources. Self-hosted options require you to pay AWS or DigitalOcean directly for the server. There's no free-tier option for persistent cloud hosting since the server runs 24/7, but you can start with a small instance ($5-10/month) and scale up if needed.
**Does cloud-hosted Claude Code support MCP integrations like Linear and GitHub?**
Yes, MCP integrations work on cloud instances exactly like local. On self-hosted servers, you configure the MCP servers in `~/.claude/mcp.json` with your API keys. On managed platforms, you connect integrations through OAuth in the web UI. The agent can query Linear issues, fetch GitHub PRs, read Notion pages, and use 500+ other tools through managed MCP integrations.
**How do I secure a cloud-hosted Claude Code instance?**
For self-hosted servers, follow standard Linux security practices: disable root SSH login, use SSH keys instead of passwords, enable UFW firewall, keep packages updated, and restrict inbound ports to only SSH (22) and your web UI port if applicable. For managed platforms, security is handled by the provider—they manage server hardening, API key encryption, and access control.
**Can I switch between local and cloud-hosted Claude Code for the same repo?**
Yes, but you need to keep git state in sync. If you start work locally and want to continue in the cloud, push your branch to GitHub first. Then on the cloud instance, pull the branch and resume. The reverse works too: pull cloud changes locally. Just avoid working on the same branch in both environments simultaneously to prevent merge conflicts.
**What happens if my cloud server crashes mid-session?**
On managed platforms, the provider monitors server health and restarts automatically. You may lose a few minutes of agent output, but git commits are safe (they're pushed to GitHub). On self-hosted servers, set up automatic restarts via systemd or supervisor. Always run Claude Code in a tmux session so you can reattach after a crash and see the last state before failure.
**How do I give team members access to a cloud-hosted Claude Code instance?**
On managed platforms, invite team members through the web UI—they get access to the same project workspace, files, and session history. On self-hosted servers, you'd need to create SSH accounts for each team member or build a shared web interface. The managed platform approach is far simpler for teams larger than 2-3 people.
**Can I run multiple Claude Code agents simultaneously on one cloud server?**
Yes, each agent runs in its own process. On self-hosted servers, start separate tmux sessions for different repos or tasks. On managed platforms, each project workspace gets its own agent instance automatically. Resource limits depend on your server specs—4GB RAM can handle 2-3 concurrent agents, 8GB can handle 5-7. Monitor CPU and memory usage to avoid slowdowns.
---
Source: https://duet.so/blog/how-to-scale-marketing-agency-without-hiring
# How to Scale a Marketing Agency to 20 Clients Without Hiring
*Scaling an agency without headcount sounds impossible. Here's how AI agents let you run 20 clients without burning out.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 14 min read.
# How to Scale a Marketing Agency to 20 Clients Without Hiring
The traditional agency growth path is linear.
More clients means more account managers, more writers, more strategists, more overhead.
Revenue goes up, but so does complexity, management burden, and the slow creep of quality control problems that come with a bigger team.
AI breaks that linearity. A well-run agency using AI for delivery, reporting, research, and content production can handle significantly more clients per person, without the quality dropping, and often with it improving.
This guide covers the specific tasks AI takes over, how to productise your services so AI can execute them, the quality control layer that keeps clients happy, and how to price your services when your cost per deliverable drops dramatically.
Quick Summary
This guide shows how to scale a marketing agency to 20+ clients without hiring. Using AI agents to handle delivery, reporting, communication, and operations so you can grow revenue without growing headcount.
Questions this page answers
- How to scale a marketing agency without hiring
- Best AI tools for marketing agency operations
- How to manage 20 clients without a big team using AI
- Can AI help run a marketing agency?
- How to automate agency delivery with AI?
## Why Do Marketing Agencies Hit a Scaling Wall at 5-10 Clients?
Each new client requires 15-20 hours of upfront work: market research, competitor analysis, SEO audits, content calendars, and monthly reporting. Traditional agencies hire junior strategists at $50-70k annually to handle this repeatable work.
The math breaks down quickly. A 10-client agency needs 2-3 full-time strategists just for research and reporting. Revenue per client needs to exceed $3,000 monthly just to cover labor costs before profit.
AI eliminates this bottleneck. The same research, analysis, and content work that takes a human 15 hours takes an AI agent 45 minutes. Cost drops from $750 in labor to $15 in API credits.
## How Does AI Handle the Repeatable 80% of Client Work?
AI agents excel at structured, repeatable tasks with clear inputs and outputs. For marketing agencies, that covers most of the work volume.
Research and analysis:
- Competitive landscape mapping
- SEO gap analysis
- Keyword research and clustering
- Market sizing and audience segmentation
- Brand positioning audits
Content production:
- Blog post outlines and drafts
- Social media content calendars
- Ad copy variations
- Email sequences
- Landing page copy
Reporting and documentation:
- Monthly performance reports
- Client strategy decks
- Campaign post-mortems
- Quarterly planning documents
The remaining 20% requires human judgment: interpreting data for strategic pivots, client relationship management, creative direction, and final content polish.
A typical workflow: AI generates 10 blog post drafts based on keyword research. A human strategist reviews, selects the best 5, and refines messaging. Total time: 2 hours instead of 20.
## What's the Step-by-Step Process for Onboarding a New Client with AI?
Day 1: Market and competitor research (45 minutes)
Start with a research prompt: "Analyze the B2B SaaS marketing landscape for [client vertical]. Identify top 10 competitors, their positioning, content themes, and SEO performance."
The AI agent scrapes competitor websites, analyzes keyword rankings, and maps content clusters. Output: a 15-page competitive landscape document with SERP position data, content gap analysis, and positioning recommendations.
Day 2: SEO and content audit (1 hour)
Run an SEO audit: "Crawl [client domain]. Identify technical issues, analyze top 20 pages for keyword optimization, find content gaps against competitors."
The agent returns a prioritized list of technical fixes, keyword opportunities, and content recommendations. You deliver this as a client-facing audit report.
Day 3: Strategy deck creation (2 hours)
Prompt: "Create a 90-day marketing strategy for [client name] based on the research. Include: positioning recommendations, content calendar with 20 topics, SEO priorities, and success metrics."
AI generates a complete deck. You spend 2 hours customizing tone, adding visual branding, and refining strategic recommendations based on client conversations.
Day 4-5: Content pipeline setup (3 hours)
Generate the first month of content assets: "Write 4 blog posts targeting [keywords]. Create social media content for LinkedIn and Twitter. Draft 2 email sequences for lead nurturing."
Review and edit output. Total time from onboarding to first content delivery: 8 hours instead of 40.
Related Reading: How to Deliver Client SEO Audits in Hours
## How Do You Manage Multiple Clients Simultaneously with AI?
The key is structured information architecture. Each client gets dedicated workspace with persistent context.
Client workspace structure:
The AI remembers all context per client. You can switch between clients instantly without re-briefing.
Parallel execution example:
Monday morning: Queue research tasks for 5 clients simultaneously.
```plaintext
Client A: Run competitor content analysis
Client B: Generate 10 LinkedIn posts for March
Client C: Audit website technical SEO
Client D: Research industry trends for Q2 planning
Client E: Create monthly performance report
```
All tasks complete in 60-90 minutes. You review outputs in the afternoon. What used to take a full week of analyst time now happens before lunch.
Related Reading: How to Automate Competitive Intelligence
## What Does a Multi-Client AI Management System Look Like?
A 15-client agency needs organized infrastructure. Here's a proven setup:
1. Client intake template
Standardize onboarding data collection:
- Brand guidelines and voice
- Target audience profiles
- Competitor URLs
- Current keyword rankings
- Content themes and topics
- Success metrics
Store this in each client's workspace files. The AI references it for every session.
2. Recurring automation schedule
Schedule these as recurring prompts. The AI executes on schedule and flags anything requiring human review.
3. Quality control workflow
Human review focuses on brand alignment, strategic accuracy, and creative polish. Not research or initial drafting.
Related Reading: How to Automate Content Creation for a One-Person Business
## How Do Pricing Models Change When AI Does the Heavy Lifting?
Traditional agency pricing ties to labor hours. AI breaks this model. You're no longer selling time; you're selling outcomes.
Old model: $5,000/month retainer for "20 hours of marketing work"
New model: $3,500/month for defined deliverables:
- 4 blog posts
- 20 social media posts
- Monthly SEO audit and recommendations
- Competitor intelligence report
- Performance dashboard
Your actual cost: $400 in AI credits + 6 hours of human review time.
Margin comparison:
You can charge 30% less and still increase profit margins by 25 points.
Value-based pricing works better: Charge based on client results, not your effort. SEO clients paying $4,000/month for 10% organic traffic growth don't care if you spent 20 hours or 2 hours delivering it.
This pricing model scales. A 3-person team can manage 15-20 clients profitably at $3,000-4,000 per client monthly. Total revenue: $45,000-80,000/month with 60%+ margins.
Related Reading: How to Build an AI-Powered SEO Strategy Without Hiring an Agency
## What Tools Do You Need to Run an AI-Driven Marketing Agency?
Core infrastructure:
1. AI agent platform - You need something that maintains context across conversations and integrates with external tools
1. SEO tools - Ahrefs or Semrush for keyword data, backlink analysis, and rank tracking ($99-199/month)
1. Analytics access - Google Analytics, Search Console, and client ad platforms
1. Content management - WordPress, Webflow, or client CMS access
1. Project management - Notion or Airtable for client deliverable tracking
AI workflow setup:
Create a dedicated server for agency work. Each client gets their own workspace with persistent files and memory. The AI remembers every session, every deliverable, and every strategic decision for that client.
When you switch from Client A to Client B, you open that client's workspace. The AI instantly recalls Client B's brand voice, competitor list, content calendar, and current campaigns. No context-switching overhead.
For parallel work across clients, you can run simultaneous research sessions in different workspaces. Queue competitor analysis for 5 clients, then review all results in batch. What used to require 5 separate analyst briefings now happens instantly.
The system learns over time. After 3 months, the AI understands each client's preferences, writing style, and strategic priorities. Content quality improves while review time decreases.
This infrastructure supports 15-20 clients with 2-3 team members. One person manages client relationships and strategy. Another handles creative direction and quality control. AI handles everything else.
## How Duet Supports Multi-Client Agency Operations
The bottleneck with most AI tools is context switching. You copy-paste client briefs every session, re-explain brand voice, and manually track what was delivered last month. Duet eliminates this by running a persistent AI agent on a cloud server that never resets.
Each client gets a dedicated workspace where the AI maintains durable session history and files — brand guidelines, competitor lists, content calendars, and past deliverables. When you start a session in Client B's workspace, it already knows Client B's voice, keywords, and strategy without re-briefing.
For agencies, the key features are cron scheduling (automated weekly competitor reports, monthly content drafts), web scraping for research (competitor blog monitoring, SERP tracking), and built-in app hosting for client dashboards. You can build a client-facing analytics dashboard in the same session where you ran the research, deploy it to a public URL, and share it with the client — no separate hosting setup.
The AI runs on your server, so scheduled tasks execute even when you are offline. Monday morning competitor briefs, weekly content drafts, and monthly reports remain in the relevant client workspace files and durable sessions. Learn more at duet.so.
Cost breakdown for 15-client agency:
Compare to hiring 2 junior strategists: $8,000-10,000 monthly loaded cost.
Related Reading: How to Set Up a 24/7 AI Agent
## What Are the Common Mistakes When Scaling with AI?
1. Treating AI like a hired employee
AI doesn't need vague instructions or motivation. It needs structured prompts with clear outputs. "Help me with content for Client X" gets poor results. "Write 4 blog posts targeting [keywords] in [brand voice] with [specific outline]" works.
2. Skipping quality control
AI produces 95% quality at 10x speed. That remaining 5% matters. Always review output for brand alignment, factual accuracy, and strategic fit. Budget 15-20% of traditional time for review.
3. Not maintaining context
If you treat each AI interaction as standalone, you'll waste time re-briefing every session. Store client context in persistent memory. Reference it explicitly: "Using the brand guidelines in #client-a, create..."
4. Underpricing because effort decreased
Your value isn't effort; it's outcomes. If AI lets you deliver the same quality in 20% of the time, you should maintain pricing (or increase it) while improving margins. Don't pass all efficiency gains to clients.
5. Over-automating client relationships
AI handles research, analysis, and content production. It doesn't replace relationship management. Clients still need human strategy calls, creative collaboration, and responsive communication.
## How Long Does It Take to Scale to 20 Clients?
Timeline from 5 clients to 20 clients:
Month 1-2: Infrastructure setup
- Build client workspace templates
- Create standard operating procedures for AI-powered delivery
- Document quality control workflows
- Test parallel client management with existing accounts
Month 3-4: Add 5 clients
- Total: 10 clients
- Team size: 2 people
- Validate that quality remains consistent at higher volume
- Refine prompts and templates based on real workload
Month 5-7: Add 5 more clients
- Total: 15 clients
- Revenue: $45,000-60,000/month
- Team size: 2-3 people
- Systematize everything that's still manual
- Consider adding part-time creative director
Month 8-12: Add final 5 clients
- Total: 20 clients
- Revenue: $60,000-80,000/month
- Team size: 3 people
- Focus shifts to client retention and service expansion
- Profit margins stabilize at 55-65%
The key constraint isn't production capacity (AI handles that). It's sales and client relationship bandwidth. One person can effectively manage relationships with 10-12 clients. Beyond that, you need another account manager.
Related Reading: How to Use AI as Your Personal Research Assistant
## What Services Should You Offer First?
Start with high-leverage, repeatable services where AI provides maximum advantage:
Tier 1: Core offerings
- SEO strategy and content production
- Competitor intelligence and market analysis
- Content marketing (blog, social, email)
These services are research-heavy, repeatable, and measurable. Perfect for AI acceleration.
Tier 2: Add after first 10 clients
- Paid ad creative and copy
- Landing page optimization
- Marketing analytics and reporting
Tier 3: Premium services (15+ clients)
- Full-funnel strategy consulting
- Brand positioning and messaging
- Multi-channel campaign management
Price tiers: $2,500 (Tier 1) → $4,500 (Tier 1+2) → $7,500 (All tiers)
Focus matters more than breadth. An agency doing SEO and content for 20 clients at $3,500/month ($70k monthly revenue) outperforms one offering 15 services to 8 clients at $6,000/month ($48k monthly revenue).
Related Reading: How to Generate Branded Social Media Content at Scale
## Frequently Asked Questions
How much can you actually charge per client when AI does most of the work?
Pricing depends on deliverables, not effort. Agencies successfully charge $3,000-5,000 monthly for packages including SEO strategy, content production, and competitive intelligence. Clients pay for results and expertise, not hours worked. Value-based pricing works better than hourly rates. A client getting 15% organic traffic growth doesn't care if you used AI to deliver it faster.
Do you need to tell clients you're using AI?
Focus on outcomes, not methods. You don't explain every internal tool or process. If asked directly, be transparent: "We use AI to accelerate research and initial drafting, with expert review and strategic oversight." Clients care about quality and results, not workflow details. Many agencies find clients prefer AI-powered delivery for faster turnarounds.
What happens if AI makes a factual error in client deliverables?
This is why quality control matters. Budget 15-20% of traditional time for human review. Check factual claims, especially statistics, quotes, and industry-specific information. Create review checklists per content type. For high-stakes content (client reports, strategy decks), use two-person review. AI accuracy improves with better prompts and context, but never skip human verification.
Can one person really manage 15-20 client accounts?
Not alone. One person can manage 8-10 client relationships while handling strategy and review. Beyond 10 clients, you need a second team member for account management or creative direction. A 20-client agency typically runs with 2-3 people: account manager, strategist/creative director, and possibly a junior for quality control and client coordination. AI handles the production work.
How do you maintain brand voice consistency across AI-generated content?
Store detailed brand guidelines in each client's workspace context. Include tone descriptors, example sentences, vocabulary preferences, and topics to avoid. Reference this explicitly in prompts: "Using the brand voice guidelines for #client-a, write..." After initial setup, AI maintains consistency better than junior writers because it perfectly recalls all guidelines without drift or interpretation.
What's the realistic timeline to profitability with this model?
Month 1-3 you're building infrastructure and processes while serving existing clients. By month 4, you can start adding clients at 2-3 per month. A typical agency reaches 12-15 clients by month 9-12, generating $40,000-55,000 monthly revenue with 2-3 team members. Profitability depends on starting point, but most agencies see 55-65% margins once processes are systematized.
Do you need technical skills to set up AI workflows?
No coding required. You need clear thinking about process structure and good prompt writing. The learning curve is 2-4 weeks to become proficient at prompting for marketing tasks. Most marketers pick it up faster than learning a new ad platform or CMS. The technical barrier is lower than learning Google Analytics or Meta Ads Manager.
---
Related Reading:
- How to Use AI to Find High-Intent Prospects for Your Freelance Business
- How to Automate Content Creation for a One-Person Business
- How to Build an AI-Powered SEO Strategy Without Hiring an Agency
- How to Deliver Client SEO Audits in Hours
- How to Generate Branded Social Media Content at Scale
- How to Build a Client-Facing Analytics Dashboard Without a Developer
- How to Write High-Converting Ad Copy with AI
---
Source: https://duet.so/blog/how-to-scrape-analyze-and-monitor-any-website
# Scrape, Analyze, and Monitor Any Website with AI
*Turn any website into a live data feed. Scrape, analyze, and monitor competitors or prospects with AI. Fully automated.*
By David. Published 2026-03-01, updated 2026-05-08. 16 min read.
# How to Scrape, Analyze, and Monitor Any Website Automatically
There's a version of competitive intelligence that happens once a quarter in a Google Doc.
And there's a version that happens continuously, automatically, and surfaces exactly the signal you need before it matters.
The difference is whether you've got an AI agent watching the web for you.
Web scraping used to require a developer, a budget, and a tolerance for brittle scrapers that broke every time a site updated its CSS.
AI changes all of that. You can now set up agents that scrape, analyse, and monitor any website, competitor pricing, product listings, hiring pages, content changes, and alert you when something meaningful shifts.
This guide covers how to do it, what's legal, and which tools actually hold up in production.
Quick Summary
This guide covers how to use AI to scrape, analyze, and monitor any website. Setting up an AI agent that watches competitor sites, pricing pages, or news sources and alerts you when something changes.
Questions this page answers
- How to scrape websites with AI
- Best AI tools for website monitoring
- How to monitor competitor websites with AI
- Can AI automatically track website changes?
- What is the easiest way to monitor a website for changes?
Modern AI web scraping tools can extract pricing data, track competitor changes, and aggregate reviews from thousands of pages. Then analyze patterns and alert you to meaningful shifts. You can automate price monitoring, job board scraping, or content research with scheduled runs that handle JavaScript rendering, authentication, and change detection without writing custom parsers.
## What Is AI-Powered Web Scraping and Why Does It Matter?
AI-powered web scraping combines traditional extraction techniques with language models that understand page structure, clean messy data, and identify meaningful changes without brittle CSS selectors.
Traditional scrapers break when a site redesigns its HTML. AI scrapers adapt by understanding content semantically. Asking "find all product prices" instead of targeting `.price-container > span.amount`. Tools like Firecrawl render JavaScript, bypass anti-bot protections, and return clean markdown or structured JSON.
**Use cases that drive business value:**
The average e-commerce team using automated price monitoring reduces response time to competitor price changes from 72 hours to under 4 hours.
## How Does Modern Web Scraping Actually Work?
Modern scraping handles three layers: fetching the page, rendering dynamic content, and extracting structured data.
**The traditional approach:**
1. Send HTTP request
1. Parse static HTML
1. Extract data with CSS selectors or XPath
1. Store raw results
**The AI-powered approach:**
1. Headless browser renders JavaScript
1. AI model identifies content structure
1. Natural language extraction ("get all pricing tiers")
1. Automatic cleaning and normalization
1. Change detection and semantic diff
Tools like Puppeteer and Playwright control headless Chrome or Firefox to render pages exactly as users see them. BeautifulSoup and lxml parse HTML efficiently. Firecrawl wraps these capabilities with AI-powered extraction that returns clean markdown, screenshots, and structured data.
**What AI adds:**
- Semantic understanding: "find contact information" works across different site layouts
- Adaptive selectors: automatically adjusts when HTML structure changes
- Data normalization: converts "$1,299.00" and "1299 USD" to consistent format
- Noise filtering: removes navigation, ads, and boilerplate automatically
The key advantage is resilience. A CSS selector like `.product-card > .price` breaks when the site updates its classes. An AI instruction like "extract product name and price" continues working.
## How to Scrape a Competitor's Pricing Page Step-by-Step
Here's how to extract pricing data from a SaaS competitor and track it over time.
**Step 1: Choose your scraping tool**
For one-off scrapes, use browser DevTools or simple Python scripts. For production monitoring, use a service:
- **Firecrawl:** API-first, handles JavaScript, returns markdown/JSON
- **Browserless:** Hosted headless browsers with anti-detection
- **ScrapingBee:** Rotating proxies, CAPTCHA solving
- **Apify:** Pre-built scrapers for common sites
**Step 2: Test the scrape manually**
```plaintext
curl -X POST https://api.firecrawl.dev/v1/scrape \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://competitor.com/pricing",
"formats": ["markdown", "html"],
"onlyMainContent": true
}'
```
Inspect the response. You should see clean pricing tier data without navigation or footers.
**Step 3: Extract structured data**
Use AI to parse the markdown into JSON:
```plaintext
curl -X POST https://api.firecrawl.dev/v1/scrape \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://competitor.com/pricing",
"formats": ["extract"],
"extract": {
"schema": {
"type": "object",
"properties": {
"plans": {
"type": "array",
"items": {
"type": "object",
"properties": {
"name": {"type": "string"},
"price": {"type": "number"},
"billing": {"type": "string"},
"features": {"type": "array", "items": {"type": "string"}}
}
}
}
}
}
}
}'
```
Response:
```plaintext
{
"plans": [
{
"name": "Starter",
"price": 29,
"billing": "monthly",
"features": ["5 users", "10GB storage", "Email support"]
},
{
"name": "Pro",
"price": 99,
"billing": "monthly",
"features": ["25 users", "100GB storage", "Priority support"]
}
]
}
```
**Step 4: Set up change detection**
Store results in a database or JSON file. On each run, compare new data to the previous snapshot:
```plaintext
import json
import difflib
def detect_changes(old_data, new_data):
old_json = json.dumps(old_data, indent=2)
new_json = json.dumps(new_data, indent=2)
diff = difflib.unified_diff(
old_json.splitlines(),
new_json.splitlines(),
lineterm=''
)
changes = '\n'.join(diff)
return changes if changes else None
```
**Step 5: Validate and clean data**
Check for common scraping errors:
- Missing required fields
- Prices that jumped 10x (likely parsing error)
- Duplicate entries
- Malformed URLs or contact info
Add validation rules:
```plaintext
def validate_plan(plan):
required = ['name', 'price', 'billing']
if not all(k in plan for k in required):
raise ValueError(f"Missing required fields: {plan}")
if plan['price'] < 0 or plan['price'] > 10000:
raise ValueError(f"Invalid price: {plan['price']}")
return True
```
Most scraping failures come from parsing errors, not extraction failures. Always validate before storing.
## How to Automate Web Scraping on a Schedule
One-off scrapes are useful for research. Automated monitoring provides ongoing intelligence.
**Option 1: Cron jobs on a persistent server**
Schedule a script to run every 6 hours:
```plaintext
# crontab -e
0 */6 * * * /usr/bin/python3 /home/scripts/scrape_competitor.py >> /var/log/scraper.log 2>&1
```
**Option 2: GitHub Actions (free tier: 2,000 minutes/month)**
```plaintext
name: Scrape Competitor Pricing
on:
schedule:
- cron: '0 */6 * * *' # Every 6 hours
jobs:
scrape:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Run scraper
run: python scrape.py
- name: Commit results
run: |
git config user.name "Bot"
git config user.email "bot@example.com"
git add data/pricing.json
git commit -m "Update pricing data"
git push
```
**Option 3: Serverless functions (AWS Lambda, Vercel, Cloudflare Workers)**
Deploy a function triggered by CloudWatch Events (AWS) or Vercel Cron:
```plaintext
// vercel.json
{
"crons": [{
"path": "/api/scrape",
"schedule": "0 */6 * * *"
}]
}
// api/scrape.js
export default async function handler(req, res) {
const response = await fetch('https://api.firecrawl.dev/v1/scrape', {
method: 'POST',
headers: {
'Authorization': `Bearer ${process.env.FIRECRAWL_API_KEY}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
url: 'https://competitor.com/pricing',
formats: ['extract'],
extract: { /* schema */ }
})
});
const data = await response.json();
// Store in database, check for changes, send alerts
res.status(200).json({ success: true });
}
```
**Option 4: Specialized monitoring tools**
- **Visualping:** Visual change detection, email alerts
- **ChangeTower:** Track specific page elements
- **Distill:** Browser extension for personal monitoring
For production systems monitoring 50+ sites, use a dedicated service. For 5-10 competitors, a cron job is sufficient.
**Setting up intelligent alerts:**
Don't alert on every change. Filter for meaningful shifts:
```plaintext
def is_significant_change(old_price, new_price):
# Alert if price changes by more than 5%
pct_change = abs(new_price - old_price) / old_price
return pct_change > 0.05
def check_pricing_changes(old_data, new_data):
alerts = []
for old_plan, new_plan in zip(old_data['plans'], new_data['plans']):
if is_significant_change(old_plan['price'], new_plan['price']):
alerts.append(f"{new_plan['name']}: ${old_plan['price']} → ${new_plan['price']}")
if alerts:
send_slack_notification('\n'.join(alerts))
```
## How to Analyze Scraped Data for Competitive Intelligence
Raw data is noise. Structured analysis produces insight.
**Pattern 1: Price positioning trends**
Track how your pricing compares to competitors over time:
```plaintext
SELECT
competitor,
plan_name,
AVG(price) as avg_price,
MIN(price) as lowest_price,
MAX(price) as highest_price
FROM pricing_snapshots
WHERE scraped_at > NOW() - INTERVAL '90 days'
GROUP BY competitor, plan_name
ORDER BY avg_price DESC;
```
**Pattern 2: Feature parity analysis**
Identify features competitors offer that you don't:
```plaintext
our_features = set(["SSO", "API access", "Custom integrations"])
competitor_features = set(["SSO", "API access", "White labeling", "Advanced analytics"])
gaps = competitor_features - our_features
# Result: {"White labeling", "Advanced analytics"}
```
**Pattern 3: Pricing change frequency**
Competitors who change prices frequently may be testing or struggling with positioning:
```plaintext
import pandas as pd
df = pd.DataFrame(pricing_history)
df['price_changed'] = df['price'] != df['price'].shift(1)
changes_by_competitor = df.groupby('competitor')['price_changed'].sum()
print(changes_by_competitor.sort_values(ascending=False))
```
**Pattern 4: Seasonal adjustments**
Some industries show clear pricing seasonality:
```plaintext
df['month'] = pd.to_datetime(df['scraped_at']).dt.month
seasonal = df.groupby('month')['price'].mean()
# E.g., B2B SaaS often increases prices in Q4 for budget season
```
**Using AI to summarize changes:**
Instead of reviewing raw diffs, ask an LLM to summarize:
```plaintext
prompt = f"""
Compare these two pricing pages:
OLD:
{old_pricing_data}
NEW:
{new_pricing_data}
Summarize what changed and why it might matter for our pricing strategy.
"""
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}]
)
summary = response.choices[0].message.content
```
The AI identifies strategic changes (new enterprise tier, bundled features) vs. cosmetic updates (button color, layout).
## What Are the Legal and Ethical Rules for Web Scraping?
Web scraping occupies a gray area between legal and illegal depending on what you scrape, how you scrape it, and what you do with it.
**Legal precedent: hiQ Labs v. LinkedIn (2019-2022)**
The Ninth Circuit ruled that scraping publicly accessible data does not violate the Computer Fraud and Abuse Act (CFAA). LinkedIn tried to block hiQ from scraping public profiles. The court found scraping public data is not "unauthorized access" under CFAA.
**Key takeaway:** Scraping public data is generally legal in the US. The Supreme Court declined to hear LinkedIn's appeal in 2022, leaving the Ninth Circuit ruling in place.
**The rules you must follow:**
1. **Respect robots.txt**: Check `/robots.txt` before scraping. While not legally binding, violating it can trigger ToS violations or IP blocks.
1. **Rate limiting**: Don't send 1,000 requests per second. Space requests 1-5 seconds apart. Most scraping bans come from aggressive rate behavior, not scraping itself.
1. **Public data only**: Don't scrape data behind authentication unless you have explicit permission. Scraping personal accounts violates ToS.
1. **Attribution and fair use**: If you republish scraped data, attribute the source. Scraping for analysis is safer than wholesale republishing.
1. **Don't circumvent technical barriers**: Using stolen credentials or cracking CAPTCHAs may violate CFAA.
1. **Terms of Service**: Violating ToS is a contract issue, not criminal, but can result in civil lawsuits or permanent bans.
**What you can safely scrape:**
- Public pricing pages
- Product catalogs
- News articles and blog posts
- Job listings on public boards
- Reviews and ratings on public platforms
- Government and regulatory filings
**What you should avoid:**
- Personal user data (emails, phone numbers) without consent
- Content behind paywalls or logins
- Sites that explicitly prohibit scraping in ToS
- Data protected by copyright (full articles, images)
**GDPR and CCPA considerations:**
If you scrape personal data of EU or California residents, you may be subject to data protection laws. Don't scrape personal emails, phone numbers, or addresses for marketing without consent.
**Best practices:**
- Identify your user agent: `User-Agent: YourCompany Bot (contact@yourcompany.com)`
- Honor `robots.txt` and `meta` tags
- Cache responses to avoid re-scraping
- Provide an opt-out mechanism if you scrape business directories
When in doubt, consult a lawyer. Scraping is low-risk for competitive intelligence but higher-risk for data resale or lead generation.
## How to Build a Complete Monitoring System with AI
A production monitoring system combines scraping, storage, analysis, and alerting.
**Architecture overview:**
1. **Scheduler**: Cron job or serverless function triggers scrapes
1. **Scraper**: Firecrawl or Puppeteer fetches and extracts data
1. **Storage**: PostgreSQL, MongoDB, or S3 for historical data
1. **Diff engine**: Compares new data to previous snapshot
1. **Analyzer**: LLM summarizes changes and identifies significance
1. **Alerter**: Slack, email, or webhook sends notifications
**Example with Duet:**
Duet provides persistent execution, scheduled cron jobs, and AI analysis in one place. You can set up Firecrawl to scrape competitor sites, store results in a JSON file on the persistent server, and use cron to check for changes every 6 hours. When prices change, Duet's AI analyzes the diff and sends a summary to your Slack channel.
Here's what that looks like in practice:
```plaintext
// scrape_monitor.js - runs every 6 hours via cron
const previousData = JSON.parse(fs.readFileSync('data/pricing.json'))
const response = await fetch('https://api.firecrawl.dev/v1/scrape', {
method: 'POST',
headers: { Authorization: `Bearer ${FIRECRAWL_KEY}` },
body: JSON.stringify({
url: 'https://competitor.com/pricing',
formats: ['extract'],
extract: {
/* schema */
},
}),
})
const currentData = await response.json()
if (JSON.stringify(previousData) !== JSON.stringify(currentData)) {
// Send to AI for analysis
const summary = await analyzePricingChange(previousData, currentData)
await sendSlackAlert(summary)
fs.writeFileSync('data/pricing.json', JSON.stringify(currentData))
}
```
The AI summary might look like:
> **Competitor X Pricing Update**
>
> - Pro plan increased from $99/mo to $119/mo (+20%)
> - New "Enterprise" tier added at $299/mo
> - Features moved: "Advanced analytics" now exclusive to Enterprise
>
> **Strategic implications:** They're pushing high-value customers to a new premium tier. Consider whether we should introduce a similar high-touch offering or emphasize our competitive pricing advantage.
Because Duet provides a persistent server with cron scheduling and AI context across runs, you don't need to stitch together separate services for scraping, storage, and analysis. Learn more at [duet.so](/).
## How Often Should You Scrape and What Should You Track?
Scraping frequency depends on how fast your market moves.
**What to track beyond pricing:**
- **Product launches**: New features, integrations, or SKUs
- **Content strategy**: Blog post frequency, topics, keyword targeting
- **SEO changes**: Title tags, meta descriptions, structured data
- **Social proof**: Review counts, ratings, testimonials
- **Team growth**: Job postings, leadership changes (via LinkedIn)
- **Technical stack**: Technologies used (via Wappalyzer or BuiltWith)
**Storage and retention:**
Don't store full HTML dumps indefinitely. Extract structured data and keep:
- Daily snapshots for the past 30 days
- Weekly snapshots for the past year
- Monthly snapshots for historical analysis
A typical competitor monitoring system tracking 10 sites stores 5-10 MB per day.
## Troubleshooting Common Scraping Problems
**Problem 1: JavaScript not rendering**
Many sites load content dynamically. Use a headless browser or a service that renders JavaScript:
```plaintext
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch()
page = browser.new_page()
page.goto('https://example.com/pricing')
page.wait_for_selector('.pricing-tier') # Wait for content to load
html = page.content()
browser.close()
```
**Problem 2: Getting blocked or rate-limited**
Rotate user agents and add delays:
```plaintext
import time
import random
headers = {'User-Agent': 'Mozilla/5.0 (compatible; YourBot/1.0)'}
time.sleep(random.uniform(2, 5)) # 2-5 second delay between requests
```
Use residential proxies or services like ScrapingBee that handle rotation automatically.
**Problem 3: CAPTCHA challenges**
Options:
- Use CAPTCHA solving services (2Captcha, Anti-Captcha)
- Reduce scraping frequency to avoid triggering CAPTCHAs
- Use authenticated API access if available
- Route through services like Browserless that provide anti-detection browsers
**Problem 4: Data extraction failures**
Sites redesign their HTML. Make extraction more resilient:
```plaintext
# Brittle
price = soup.select_one('.price-container > span.amount').text
# More resilient
price = soup.find(string=re.compile(r'\$\d+')) or \
soup.select_one('[data-testid="price"]') or \
soup.find('span', class_=re.compile('price'))
```
Or use AI-based extraction that doesn't rely on CSS selectors.
**Problem 5: Inconsistent data format**
Normalize extracted data:
```plaintext
def normalize_price(price_string):
# "$1,299.00" → 1299.0
# "1299 USD" → 1299.0
# "€1.299,00" → 1299.0
# Remove currency symbols and letters
cleaned = re.sub(r'[^\d,.]', '', price_string)
# Handle European format (. for thousands, , for decimal)
if ',' in cleaned and '.' in cleaned:
if cleaned.rindex(',') > cleaned.rindex('.'):
# European: 1.299,00
cleaned = cleaned.replace('.', '').replace(',', '.')
else:
# US: 1,299.00
cleaned = cleaned.replace(',', '')
elif ',' in cleaned:
# Could be either format, use position to guess
if len(cleaned.split(',')[1]) == 2:
# Likely decimal: 1299,00
cleaned = cleaned.replace(',', '.')
else:
# Likely thousands: 1,299
cleaned = cleaned.replace(',', '')
return float(cleaned)
```
## Frequently Asked Questions
### Is web scraping legal?
Scraping public data is generally legal in the US following the hiQ v. LinkedIn ruling (2022). However, you must respect terms of service, avoid scraping personal data without consent, and follow GDPR/CCPA rules if collecting information about EU or California residents. Always scrape responsibly with rate limiting and attribution.
### What is the best AI web scraper for beginners?
Firecrawl is the easiest option for beginners, it handles JavaScript rendering, returns clean markdown or JSON, and offers AI-powered extraction without writing parsers. For more control, Playwright or Puppeteer with Python gives you full browser automation. Apify provides pre-built scrapers for popular sites like Amazon, LinkedIn, and Twitter.
### How can I monitor competitor prices automatically?
Use a scraping tool like Firecrawl to extract pricing data, schedule it to run every 6-24 hours with cron or GitHub Actions, store results in a database or JSON file, compare new data to previous snapshots, and send alerts when prices change by more than 5%. Services like Visualping or ChangeTower offer no-code alternatives.
### Can I scrape websites for lead generation?
You can scrape public business information (company names, websites, job titles) from directories and LinkedIn. However, scraping personal emails or phone numbers for cold outreach may violate GDPR/CCPA and site terms of service. Focus on scraping public data and enriching it through legitimate APIs like Clearbit or Apollo.
### How do I avoid getting blocked while scraping?
Add 2-5 second delays between requests, rotate user agents, use residential proxies, respect robots.txt, and scrape during off-peak hours. Services like ScrapingBee and Bright Data provide built-in anti-detection. If you're consistently blocked, reduce your rate or use the site's official API if available.
### What's the difference between web scraping and using an API?
APIs provide structured data through official endpoints with rate limits and terms of use. Web scraping extracts data from HTML pages designed for humans. Always prefer APIs when available. They're faster, more reliable, and legally clearer. Scrape only when no API exists or when you need data the API doesn't expose.
### How accurate is AI-powered web scraping?
AI scrapers achieve 85-95% accuracy on well-structured sites, compared to 95-99% for manual CSS selectors. The tradeoff is resilience, AI extraction continues working after site redesigns while CSS selectors break. For mission-critical data, combine AI extraction with validation rules and manual spot checks.
---
Source: https://duet.so/blog/how-to-set-up-a-24-7-ai-agent
# How to Run Claude Code 24/7: Setup Guide for Always-On AI Agents
*Run Claude Code 24/7 without babysitting sessions. Compare tmux, systemd, and Docker to a persistent, zero-setup server that keeps your AI agent always on.*
By David. Published 2026-03-01, updated 2026-07-06. 12 min read.
# How to Run Claude Code 24/7?
Quick answer
Claude Code is a terminal-first CLI, so it dies when your SSH connection drops, your laptop sleeps, or the machine reboots. You can stretch its uptime with tmux, nohup, systemd, or Docker, but each one adds maintenance. To actually run Claude Code 24/7 with zero babysitting, host it on a persistent server like [Duet](/) that stays up and keeps your agent's context across restarts.
You fire up Claude Code in your terminal, give it a solid prompt, and step away to grab coffee.
Ten minutes later you're back, and the session is gone. SSH dropped, laptop slept, or the process just quietly died. Your agent's context? Vanished. The work you thought was running? Never happened.
Claude Code was built for interactive terminal sessions, not for staying alive on its own. Most developers try the usual fixes, tmux, screen, nohup, systemd services, and they help, until they don't.
You still end up babysitting processes, restoring context, and wondering why something this useful has to be this fragile.
You don't actually need to become a DevOps babysitter just to keep an AI coding agent running 24/7.
In this post I'll show you the practical ways people force Claude Code to stay alive in the terminal (with all their messy trade-offs). Then I'll show you the dramatically simpler path: running it on a persistent, zero-setup server that just works, no SSH gymnastics, no lost context, no maintenance.
If you want Claude Code that actually runs while you sleep, let's get into it.
## Why Claude Code Can't Run 24/7 Out of the Box
Claude Code is fundamentally a terminal-first tool. It expects an active, interactive session, which is exactly why it shines when you're sitting in front of it, but starts showing cracks the moment you walk away.
Here's what usually happens:
- Your SSH connection drops (or your laptop sleeps) and the process dies with it.
- Even with tmux or screen, a server reboot, OOM kill, or unhandled error can wipe the session entirely.
- Context doesn't survive restarts automatically. Claude Code has a `--continue` flag that can resume the most recent conversation, but you have to invoke it manually, re-orient the agent, and hope it picks up where it left off cleanly. More often than not, you're re-explaining the task.
- There's no built-in heartbeat or auto-recovery. If something breaks at 2 a.m., it just stays broken until you notice.
The result? You end up treating a coding agent like a houseplant that needs constant watering. You check on it, restart it, re-brief it, and hope it didn't lose the thread.
Most of the "run it 24/7" advice online is really just a collection of terminal hacks, tmux sessions, supervisor scripts, and keep-alive loops, all of which reduce the babysitting but never eliminate it.
They work until they don't. And when they don't, you're back to debugging your debugging tools.
This is the hidden tax of running Claude Code the traditional way.
## Practical Ways to Keep Claude Code Running Longer
If you're determined to stay in the terminal, there are several established patterns people use to reduce how often they have to restart Claude Code.
None of them are truly hands-off, but they do buy you more uptime than a raw interactive session.
### Session Persistence with screen or tmux
The most common first step is detaching your session from the terminal so it survives SSH disconnects or laptop sleep.
- screen (older, simpler) and tmux (more powerful, modern default) both let you start Claude Code inside a detachable session.
- You can detach (Ctrl+B D in tmux), close your laptop, and reconnect later to reattach.
- The process keeps running on the remote machine as long as the machine itself stays up.
Limitation: These tools only protect against terminal detachment. A server reboot, OOM killer, or uncaught crash will still terminate the session. You'll come back to a dead process and need to restart Claude Code manually (then use `--continue` if you want to resume the last conversation).
### nohup, disown, and Background Processes
For quick-and-dirty persistence without a full multiplexer:
```bash
nohup claude [your prompt] > output.log 2>&1 &
disown
```
This tells the shell to ignore hangup signals and run the process in the background.
Limitation: Still vulnerable to machine-level events (reboots, OOM, crashes). No automatic restart. Logs help with debugging but don't restore state.
### Systemd Services (Linux) or launchd (macOS)
For a more robust setup, wrap Claude Code in a service manager so the OS treats it like any other long-running daemon.
- On Linux you can write a systemd unit file with `Restart=always` or `Restart=on-failure`.
- On macOS, launchd plists give you similar keep-alive behavior.
This survives SSH drops and some crashes better than raw tmux.
Limitation: Still requires you to maintain the service definition, handle log rotation, manage dependencies, and monitor for silent failures. Not zero-maintenance.
### Docker Containers and Restart Policies
Containerizing the environment gives you isolation and a clean restart policy:
```bash
docker run -d --restart unless-stopped your-claude-image
```
You can combine this with tmux inside the container or run it as a service.
Limitation: You're now managing Dockerfiles, image updates, volume mounts for context, and container orchestration. One more layer that can break.
### Cloud VMs or Dedicated Servers
The nuclear option is to spin up a cheap cloud VM (Hetzner, DigitalOcean, AWS, etc.), install Claude Code, and leave it running 24/7.
You get real uptime (assuming the provider stays healthy) and can combine it with any of the above tools.
Limitation: Now you have infrastructure to pay for, secure, update, and monitor. Cost, SSH keys, firewall rules, and occasional provider maintenance all become your problem.
These approaches all reduce the babysitting burden compared to a raw terminal session. But they share the same core issues: manual restarts, fragile context recovery (even with `--continue`), and ongoing operational overhead.
Most developers eventually hit a point where the maintenance tax outweighs the benefit, and that's where a different approach starts to look attractive.
## How to Run Claude Code 24/7 on Duet
Getting Claude Code running 24/7 on Duet takes just a few minutes and requires zero infrastructure setup.
### Create your Duet server
Head to [duet.so](/) and sign up (or log in). Every account gets its own dedicated server environment, this is where your agents will live and run persistently.
### Connect Claude Code
Inside your Duet server you can install and run Claude Code exactly as you would in any terminal. The difference is that this terminal lives on a server that stays up 24/7.
```bash
# Example: install and start Claude Code inside your Duet server
claude --help
```
You can start agents, give them tasks, and detach, they'll keep working even if you close your browser or laptop.
### Set up recurring or long-running work
Duet supports running agents as background processes or scheduled tasks. You can:
- Kick off a long-running coding or research task and leave it
- Set up recurring agent runs (e.g., daily code reviews, monitoring jobs)
- Use Duet's built-in memory so agents retain context across restarts
No tmux, no systemd unit files, no Docker restart policies.
### Monitor and collaborate
Agent work is visible in durable Duet sessions. Teammates can follow session events, review outputs, or continue the work without needing SSH access. The durable event history remains attached to the session.
### Final Step
Your Claude Code agents now run on infrastructure designed for persistence. When you come back hours or days later, the work is still there, no manual `--continue` flags, no lost context, no surprise crashes.
The entire flow is deliberately minimal: sign up, connect Claude Code, let it run. No provisioning, no maintenance, no hidden DevOps work.
## Terminal Hacks vs. Duet
Here's how the two approaches stack up in practice:
- If you enjoy tinkering with infrastructure and want full control over every layer, the terminal route still works, just expect to keep paying the maintenance tax.
- If your goal is "Claude Code that actually runs while I'm not looking," Duet removes the entire category of problems instead of patching around them.
Many developers who try both end up settling on Duet for anything that needs to run longer than a single focused session. If you want to see the managed path in detail, here is how to [run Claude Code in the cloud](/blog/how-to-run-claude-code-in-the-cloud).
## When Terminal Still Makes Sense
Not every use case needs a persistent server. Here's a quick decision framework.
Stick with terminal hacks when:
- You're doing short, focused sessions (a few hours at most)
- You're already comfortable with tmux or Docker and the maintenance overhead doesn't bother you
- You need full control over the environment (specific OS packages, custom networking, air-gapped setups)
- Budget is extremely tight and you already have spare VMs or local hardware
Switch to Duet when:
- You want agents running overnight, over weekends, or across days without checking in
- You value your time more than the cost of a managed server
- You work with a team and need shared visibility without sharing SSH credentials
- You've already spent more time babysitting processes than actually building
- You want to test an always-on agent without first becoming a part-time sysadmin
The pattern most developers follow is simple. Start in the terminal, feel the friction, then move to Duet once the maintenance tax becomes obvious. There's no shame in either path, the right choice is the one that lets you ship without the tool fighting you.
## Our Verdict
Claude Code is powerful, but it was designed for focused, interactive terminal sessions, not for running unattended. The terminal hacks (tmux, systemd, Docker, VMs) can stretch it further, but they all share the same hidden cost: you become the babysitter.
Duet flips the model. Instead of bolting persistence onto a tool that wasn't built for it, you get an always-on server environment where Claude Code (and any other agent) simply stays alive. No SSH, no config files, no `--continue` flags, no 2 a.m. restarts. Just agents that keep working while you're not looking.
If you've ever come back to a dead session and wondered why this has to be so fragile, you already know the problem. The solution is choosing infrastructure that was designed for 24/7 from day one.
Ready to stop babysitting your Claude Code?
Try Duet free, spin up your first always-on server and connect Claude Code in under two minutes. No credit card, no infrastructure to manage, no maintenance tax.
## Frequently Asked Questions
### Can Claude Code run without a terminal?
Not on its own. Claude Code is a terminal-first CLI built for interactive sessions, so it needs an active shell to run. To use it without keeping a terminal open, you host it on a persistent server (a cloud VM or a managed environment like Duet) where the process stays alive after you close your laptop.
### Does Claude Code work with tmux?
Yes. Running Claude Code inside tmux (or screen) is the most common way to keep a session alive after an SSH disconnect. tmux protects against terminal detachment, but not against server reboots, OOM kills, or crashes, so it buys you uptime rather than true hands-off 24/7 operation.
### How do I keep Claude Code running overnight?
Detach the session from your terminal so it survives disconnects. The usual options are tmux or screen, a systemd or launchd service with auto-restart, a Docker container with a restart policy, or a persistent server like Duet that stays up 24/7 with none of that setup.
### Is Claude Code available as a cloud service?
Anthropic ships Claude Code as a local CLI, not a hosted service. To run it in the cloud you install it on your own server, or use a managed environment like Duet, which gives every account a persistent always-on server where Claude Code keeps running after you log off.
### What happens to my Claude Code session when SSH disconnects?
By default the process dies with the connection and the session is lost. tmux or screen keep it alive through an SSH drop, and a persistent server keeps it running regardless. Claude Code's `--continue` flag can resume the most recent conversation, but only if the process and its state survived.
### Can you run Claude Code 24/7 without any maintenance?
Yes, if you run it on Duet. The server stays up, the agent keeps its state, and you don't need to restart processes or manage infrastructure. Terminal setups can get close with enough workarounds, but they always require some level of monitoring.
### How is Duet different from just using a VPS?
A VPS gives you a machine; you still have to install Claude Code, set up tmux or systemd, handle updates, manage logs, and deal with crashes. Duet gives you the same always-on environment with all of that already handled. No SSH, no config files, no maintenance.
### Does Duet work with other coding agents besides Claude?
Yes. Duet is agent-agnostic, you can run Claude Code, Cursor, Aider, or any terminal-based agent inside your persistent server. The 24/7 behavior comes from the server, not the specific tool.
### What happens if my laptop is off while using Duet?
Nothing changes. Your Duet server runs independently of your local machine. Close your laptop, shut down your Wi-Fi, go on vacation, the agents keep working.
### Is there a free way to test Duet?
Duet offers a 7-day free trial so you can spin up a server and try running Claude Code 24/7 before choosing a monthly plan. Most people know within the first session whether the persistent model fits their workflow.
---
Source: https://duet.so/blog/how-to-set-up-ai-customer-service-small-business
# Set Up an AI Customer Service Agent for Your Biz
*Replace your support backlog with an AI agent that resolves tickets 24/7. Set it up in an afternoon. No ML degree required.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 13 min read.
# How to Set Up an AI Customer Service Agent for Your Small Business
Customer support is one of those functions that scales badly by default.
The more customers you have, the more tickets you get, and at some point you're either hiring more support staff or letting response times slip. Neither is a great option for a growing business.
An AI customer service agent breaks that scaling curve.
Done well, it handles the majority of inbound queries instantly, at any hour, without degrading the customer experience. It escalates the edge cases that actually need a human.
This guide covers what to automate, what not to, how to train the agent on your specific products and policies, and the escalation design that keeps customers from feeling stuck.
Quick Summary
This guide walks through setting up an AI customer service agent that handles FAQs, triages tickets, escalates edge cases, and responds across email, chat, and social. Giving you 24/7 support without a full support team.
Questions this page answers
- How to set up an AI customer service agent
- Best AI tools for customer support automation
- Can AI handle customer service without humans?
- How to build a 24/7 AI support agent
- How to automate customer support with AI?
## Why Small Businesses Need AI Customer Service
Your customers expect instant responses. Research shows 46% of customers expect companies to respond within four hours, but most small businesses can't staff support desks around the clock.
The traditional options both fail:
- Hire a support team: Costs $30,000-$50,000 per full-time agent annually
- Answer everything yourself: Caps your business growth at your personal availability
AI automation for small business solves this by handling repetitive questions automatically. You answer each question once in your knowledge base, and the AI handles every future instance.
## What an AI Customer Service System Actually Does
At the core, an AI customer service agent performs four operations:
1. Receives incoming messages via webhook, email, or chat widget
1. Searches your knowledge base for relevant context
1. Generates a response using that context and conversation history
1. Routes complex cases to humans based on confidence thresholds
The system runs continuously on a server, not your laptop. When a customer sends a message at 2 AM, the webhook fires, the agent processes it, and the customer gets an answer in seconds.
## Step-by-Step: Building Your First Support Agent
### Create Your Knowledge Base
Your knowledge base is the foundation. The AI can only answer questions you've documented.
Start with these categories:
Write each answer as if speaking to a customer directly. Use plain language and include specific details like timeframes, costs, and step numbers.
Example good knowledge base entry:
```plaintext
Q: How do I reset my password?
A: Go to the login page and click "Forgot Password" below the sign-in button. Enter your email address and click "Send Reset Link." You'll receive an email within 2 minutes with a link that's valid for 24 hours. Click the link and enter your new password twice. If you don't see the email, check your spam folder.
```
Save your knowledge base as plain text, Markdown, or structured data (JSON/CSV). The format matters less than the content quality.
### Set Up Your AI Model
You need a language model with these capabilities:
- Function calling: Allows the model to search your knowledge base
- Conversation memory: Maintains context across multiple messages
- System instructions: Lets you define tone and escalation rules
Claude, GPT-4, or similar models all work. The key is connecting the model to your knowledge base through a search function.
Here's the basic architecture:
```plaintext
Customer Message → Webhook → Your Server → AI Model → Search Knowledge Base → Generate Response → Send to Customer
```
The server is critical. Desktop AI tools like ChatGPT can't receive webhooks or run 24/7. You need a persistent environment.
This is where most small business setups break. You can build a great support agent on your laptop, but the moment you close it, the system stops working. Customer messages arrive, webhooks fire, and nothing responds.
A cloud server solves this. Duet provides this infrastructure specifically for AI agents. The agent runs continuously, receives webhooks, maintains conversation memory, and handles requests whether you're online or not.
For detailed setup instructions, see How to Set Up a 24/7 AI Agent.
### Connect Your Communication Channels
Your customers need a way to reach the AI. Common integration points:
Email Support:
- Set up email forwarding to your server
- Agent parses incoming emails, searches knowledge base, sends replies
- Maintains thread context using email headers
Live Chat Widget:
- Embed JavaScript widget on your website
- Widget sends messages to your webhook endpoint
- Agent responds in real-time through WebSocket or polling
Social Media:
- Connect to Facebook Messenger, Twitter DMs, or WhatsApp
- Platform APIs forward messages to your webhook
- Agent posts responses through the same API
Start with one channel. Email is often easiest because every business already has a support address.
### Write Your System Instructions
System instructions define how your AI behaves. Be specific about tone, escalation rules, and boundaries.
Example system instructions:
```plaintext
You are a customer service agent for [Company Name]. Your job is to answer customer questions using the knowledge base.
Tone: Friendly and professional. Use contractions. Keep answers concise but complete.
When to escalate:
- Customer is angry or uses profanity
- Question requires account access you don't have
- Knowledge base doesn't contain relevant information
- Customer explicitly requests human support
Format responses:
- Answer the question directly in the first sentence
- Provide additional context or steps afterward
- End with "Is there anything else I can help with?"
Never:
- Make promises about features or timelines
- Guess if you're uncertain
- Share information not in the knowledge base
```
The more specific your instructions, the more consistent the behavior.
### Add Context-Aware Search
The AI needs to find the right knowledge base entries. Simple keyword matching fails for questions phrased differently than your documentation.
Use semantic search instead:
1. Convert knowledge base to embeddings (vector representations)
1. Convert customer question to embedding
1. Find most similar entries using cosine similarity
1. Pass top 3-5 results to the AI as context
This handles variations automatically. "How do I change my password?" and "I forgot my login credentials" both match the password reset documentation.
Most embedding APIs cost less than $0.01 per 1,000 searches.
### Implement Confidence Scoring
Not every question has a clear answer. The AI should know when to escalate.
Add confidence checks:
```python
def should_escalate(search_results, customer_message):
# Check if knowledge base search found relevant results
if search_results[0].similarity_score < 0.7:
return True, "No relevant documentation found"
# Check for escalation keywords
escalation_phrases = ["speak to a human", "cancel my account", "refund"]
if any(phrase in customer_message.lower() for phrase in escalation_phrases):
return True, "Customer requested human support"
# Check conversation length (stuck in loop)
if conversation_turn_count > 5:
return True, "Extended conversation may need human help"
return False, None
```
When escalation triggers, notify your team via Slack, email, or support ticket system.
## Handling Edge Cases in AI Customer Service
### Multi-Language Support
If you serve international customers, handle multiple languages:
Option 1: Translate incoming messages to English
- Detect language using language detection API
- Translate to English, process normally
- Translate response back to original language
- Cost: ~$0.0001 per message with Google Translate API
Option 2: Maintain multilingual knowledge base
- Duplicate documentation in each supported language
- More accurate but requires translation maintenance
- Best for high-volume languages
Start with translation. Switch to native documentation when a language reaches 100+ monthly inquiries.
### Maintaining Brand Voice
Your AI should sound like your company. Define voice attributes explicitly:
Include 5-10 example responses in your system instructions showing the exact tone you want.
### Privacy and Security
Customer service often involves personal information. Implement safeguards:
- Never log sensitive data like credit card numbers or passwords
- Redact PII before saving conversation history
- Limit knowledge base access to non-sensitive information
- Add human review for account changes or refunds
If a question requires account access, escalate immediately rather than asking customers to share credentials.
### When Systems Break
Build fallbacks for common failure modes:
Test failure scenarios during setup. Don't wait for customers to find them.
## Measuring AI Customer Service Success
Track these metrics to evaluate performance:
### Response Time
Target: < 30 seconds for initial response
Measure from webhook receipt to response sent. AI should dramatically outperform human agents (typical: 4-24 hours).
### Resolution Rate
Target: > 70% fully resolved without escalation
Calculate: (conversations marked resolved) / (total conversations)
If resolution rate drops below 60%, audit recent escalations to identify knowledge base gaps.
### Customer Satisfaction
Target: > 4.0/5.0 rating
Send a one-question survey after each resolved conversation: "Did this answer your question?" with 1-5 star rating.
Track satisfaction separately for AI-only vs. AI-then-human conversations. AI-only should match or exceed blended scores.
### Cost Per Conversation
Target: < $0.10 per conversation
Include API costs (model, embeddings, translation) plus server hosting. Compare to human agent cost (~$2-5 per conversation).
### Coverage Rate
Target: > 90% of questions mappable to knowledge base
Audit escalated conversations monthly. If the same question escalates repeatedly, add it to your knowledge base.
## Example: Full Support Flow
Here's what a complete interaction looks like:
1. Customer sends email: "Do you ship to Canada?"
1. Email forwarded to webhook at your server
1. AI searches knowledge base for "shipping Canada"
1. Finds relevant entry: "We ship to Canada via USPS. Delivery takes 7-10 business days. Shipping costs $15 USD for orders under $100."
1. AI generates response: "Yes, we ship to Canada. Delivery takes 7-10 business days via USPS, and shipping costs $15 USD for orders under $100. Is there anything else I can help with?"
1. Response sent via email reply
1. Conversation logged for quality review
Total time: 3-8 seconds. Total cost: $0.02.
If the customer responds, the AI maintains conversation context and can answer follow-up questions without repeating information.
## Common Implementation Mistakes
### Building on a Laptop Instead of a Server
Many businesses build their support agent locally, test it successfully, then wonder why it doesn't respond to real customers. Webhooks require a publicly accessible endpoint that runs continuously.
Use a cloud server from day one. The cost difference ($5-20/month) is negligible compared to one lost customer.
### Writing Knowledge Base in AI Speak
Your knowledge base should sound human, not like documentation for an AI. Write as if answering a customer directly.
Bad: "Password reset functionality accessible via authentication recovery endpoint"
Good: "Click 'Forgot Password' on the login page to reset your password"
### No Escalation Path
Every AI will encounter questions it can't answer. Without a clear escalation path, customers get stuck in loops.
Define exact escalation triggers and test them weekly.
### Ignoring Conversation History
Each customer message doesn't exist in isolation. If someone asks "Do you ship to Canada?" then follows up with "How much does it cost?", the AI needs context to know "it" means Canadian shipping.
Use conversation memory that persists for at least 24 hours.
### Treating All Questions Equally
Simple questions ("What are your hours?") should resolve in one message. Complex questions ("I was charged twice and need a refund") require escalation.
Implement question complexity detection and adjust response accordingly.
## Advanced: Proactive Support
Once your reactive system works, add proactive features:
Order Updates:
When order status changes in your system, trigger webhook to AI. AI sends personalized update to customer.
Follow-Up Sequences:
After purchase, schedule AI follow-ups at day 3 (usage check-in), day 14 (satisfaction survey), day 30 (renewal reminder).
Trend Detection:
If multiple customers ask the same question in a short period, alert your team to potential product issues.
For more on building automated workflows, see How to Use AI to Run Startup Operations with a 3-Person Team.
## Frequently Asked Questions
### How much does it cost to run an AI customer service agent?
Total monthly costs typically range from $50-200 for small businesses. This includes: server hosting ($5-20), AI API calls ($20-100 depending on volume), and embedding API for search ($5-20). Compare this to $3,000-5,000 monthly for a single human agent.
### What happens when the AI doesn't know the answer?
The system should detect low-confidence responses using similarity scoring and escalate to a human immediately. Include a fallback message like "This question needs human expertise. I've notified the team and someone will respond within 4 hours." Never let the AI guess or make up answers.
### Can AI handle angry or frustrated customers?
AI can detect negative sentiment through keyword analysis and tone detection, but should escalate these cases to humans immediately. Angry customers need empathy and problem-solving that AI isn't equipped to provide. Set escalation triggers for phrases like "ridiculous," "unacceptable," or profanity.
### How do I prevent the AI from giving wrong information?
Use a curated knowledge base as the single source of truth and configure the AI to only answer questions with direct knowledge base matches. Add this to system instructions: "If you cannot find relevant information in the knowledge base, say 'I don't have that information' and escalate." Review escalated conversations weekly to identify knowledge base gaps.
### How long does it take to set up an AI customer service agent?
Initial setup takes 4-8 hours: 2 hours to create a basic knowledge base, 2 hours to configure the AI model and search function, 1-2 hours to connect your first communication channel, and 1-2 hours to test edge cases. After launch, expect 2-4 hours weekly to review conversations and update the knowledge base.
### Can I integrate this with my existing help desk software?
Yes. Most help desk platforms (Zendesk, Freshdesk, Help Scout) offer API access. You can configure the AI to create tickets for escalated cases, add internal notes, or update ticket status. Some platforms also support bot users that can respond directly within the existing ticket interface.
### What if my customers prefer talking to humans?
Always provide an opt-out. Include "Type HUMAN to speak with someone from our team" in initial AI responses. Track opt-out rates as a metric. If more than 20% of customers immediately request human support, audit your AI's tone and response quality. Some industries (healthcare, legal, high-value B2B) may see higher opt-out rates due to complexity.
---
Source: https://duet.so/blog/how-to-set-up-ai-sales-prospecting-startups
# How to Set Up AI-Powered Sales Prospecting for Your Startup
*Find your next 100 customers in hours, not weeks. AI-powered sales prospecting that actually converts for early-stage startups.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 11 min read.
# How to Set Up AI-Powered Sales Prospecting for Your Startup
Early-stage sales is mostly a numbers game with a quality filter.
You need to reach enough of the right people, fast enough, without burning your domain reputation or spending 80% of your week on research.
Most founders either send too few messages (not enough pipeline) or too many to the wrong people (bad conversion, flagged as spam).
AI-powered sales prospecting changes the math.
You can build targeted lead lists, enrich contact data, personalise at scale, and run sequenced follow-ups, without hiring an SDR team.
This guide walks through exactly how to set it up for your startup, what tools actually work in 2026, and where AI still needs a human in the loop.
Quick Summary
This guide walks through setting up an AI-powered sales prospecting system. Automating lead discovery, contact enrichment, and outreach sequencing to replace manual research and expensive tools like Clay or Apollo.
Questions this page answers
- How to set up AI sales prospecting for a startup
- Best AI tools for sales prospecting
- How to automate lead generation with AI
- Can AI replace Clay or Apollo for prospecting?
- How to build an AI outreach system for startups
## Why Manual Prospecting Kills Early-Stage Velocity
Manual prospecting consumes 3-4 weeks per month for early-stage founders. You're building product, closing early customers, and iterating on positioning. Prospecting falls to nights and weekends.
The traditional approach looks like this:
At 15 prospects per day, you reach 300 per month. That's barely enough volume to validate messaging, let alone build pipeline.
The opportunity cost is massive. Every hour spent manually enriching leads is an hour not spent on product or customer calls.
## The AI Prospecting Stack for Startups
Modern AI prospecting combines four capabilities: target identification, data enrichment, contact discovery, and personalized outreach.
**Target Identification:** Tools like Crustdata and Apollo search firmographic databases to surface companies matching your ICP. Define criteria (industry, employee count, funding stage, tech stack) and receive ranked lists.
**Data Enrichment:** FullEnrich, Clearbit, and Apollo append company details. Revenue estimates, funding history, tech stack, growth signals. This data powers relevance scoring and personalization.
**Contact Discovery:** Email finders (Hunter.io, Apollo, FullEnrich) locate decision-maker contacts with verification. Expect 60-75% deliverability on verified emails.
**Personalized Outreach:** AI models analyze enriched data and write contextual emails. GPT-4o and Claude Opus 4.6 generate opening lines referencing recent funding, product launches, or hiring patterns.
The stack runs sequentially: identify targets → enrich data → find emails → generate outreach → send sequences.
## Step 1: Define Your Ideal Customer Profile (ICP)
Start with firmographic boundaries. Your ICP should be specific enough to drive automated filtering but broad enough to generate volume.
Example B2B SaaS ICP:
- Industry: SaaS, fintech, healthtech
- Employee count: 20-200
- Funding stage: Series A or later
- Location: North America
- Tech stack: Uses Salesforce, Stripe, or Segment
- Growth signals: Hiring for sales roles in last 60 days
Avoid vague criteria like "innovative companies" or "fast-growing startups." Use measurable attributes available in firmographic databases.
Test your ICP against your best 10 existing customers. If 7+ match the criteria, you've found signal. If fewer than 5 match, tighten or expand boundaries.
## Step 2: Build Your Target List with Automated Filters
Use Crustdata, Apollo, or Harmonic to query firmographic databases. Most tools support Boolean filters and ranked results.
Sample Crustdata query:
```plaintext
industry:("SaaS" OR "fintech") AND
employee_count:[20 TO 200] AND
funding_stage:"Series A" AND
location:"United States" AND
tech_stack:"Salesforce" AND
hiring_activity:true
```
This returns ~500-2,000 companies depending on specificity. Export the list with company name, domain, employee count, and funding data.
For higher quality, layer in intent signals:
- Recent funding announcements (last 90 days)
- Product launches or rebrandings
- Expansion hiring (sales, customer success roles)
- Tech stack changes (new tools adopted)
These signals indicate buying windows, moments when companies are more likely to consider new vendors.
## Step 3: Enrich with Firmographics and Decision-Maker Contacts
Upload your target list to FullEnrich or Apollo for enrichment. Request:
- Annual revenue estimate
- Total funding raised
- Key tech stack components
- LinkedIn profiles for VP Sales, CRO, or Head of Growth
- Verified work emails for decision-makers
Enrichment costs $0.10-0.50 per record depending on data depth. Budget $100-250 to enrich a 500-company list.
FullEnrich waterfall searches 15+ data sources and returns the first verified email found. Expect 65-80% match rates for mid-market companies with public decision-makers.
For missing contacts, use LinkedIn Sales Navigator to identify the right person, then run their profile through Hunter.io or Apollo's email finder.
## Step 4: Write Personalized Emails That Don't Sound Like AI
Generic AI emails get 2-3% reply rates. Personalized emails referencing specific company data hit 15-25%.
The difference is context depth. Instead of "I noticed your company is growing," reference actual signals:
> "Saw you raised $12M Series A in January and just posted 3 customer success roles. Looks like you're scaling post-sale motions fast."
GPT-4o and Claude Opus 4.6 can generate these lines when provided enriched data. Structure your prompt:
```plaintext
Write a cold email opening line for [Company Name].
Context:
- Raised $12M Series A in January 2026
- Hiring 3 customer success roles
- Uses Salesforce and Stripe
- Our product helps companies automate onboarding sequences
Make it specific, conversational, and focused on their growth stage.
```
Output:
> "Congrats on the Series A. Adding 3 CS roles in one shot means you're bracing for serious onboarding volume. Most teams at your stage hit a wall around 50 new customers per month when manual onboarding breaks."
Combine AI-generated openers with your standard pitch structure:
1. Personalized opener (AI-generated, 1-2 sentences)
1. Problem statement (based on their growth stage)
1. Specific value prop (what you solve)
1. Low-friction CTA (15-min call or quick question)
Keep emails under 100 words. Each additional sentence drops reply rate by 2-3%.
## Step 5: Automate Sequences with Follow-Ups
Single emails get 8-12% reply rates. Three-touch sequences hit 20-30%.
Standard startup prospecting sequence:
**Day 0:** Initial email with personalized opener
**Day 3:** Value-add follow-up (share relevant case study or insight)
**Day 7:** Breakup email ("Should I close your file?")
Each email should stand alone. Recipients won't remember your first email. Restate context briefly.
Tools like Lemlist, Instantly, and Smartlead automate sequences and track opens, clicks, and replies. Costs run $50-100/month for 1,000-2,000 emails.
Set up automated stop conditions:
- Stop sequence on reply
- Stop on link click
- Stop if out-of-office detected
Monitor reply rates by sequence step. If Day 3 emails outperform Day 0, your initial targeting might be off. People need more context to engage.
## Running the Full Pipeline in Duet
Duet can orchestrate the entire prospecting pipeline, from ICP research to automated email sequences, without jumping between 6 different tools.
Here's how a typical startup prospecting workflow runs:
Start by defining your ICP in a conversation: "Find Series A SaaS companies with 20-200 employees that use Salesforce and hired sales roles in the last 60 days." Duet searches firmographic databases through Crustdata or Apollo and returns a ranked list.
Next, enrich the list: "For these 200 companies, find VP Sales or CRO contacts with verified emails." Duet calls enrichment tools like FullEnrich, aggregates results, and outputs a clean CSV with contact details, funding data, and hiring signals.
Then generate personalized emails: "Write a personalized cold email for each prospect referencing their recent funding and hiring activity." Duet analyzes each company's enriched data and generates contextual openers at scale.
Finally, set up the sequence: "Upload these emails to Lemlist and configure a 3-touch sequence with Day 0, Day 3, and Day 7 emails." Duet can prepare the upload file or even configure sequences through API integrations.
The entire process, from ICP definition to live email sequence, runs in one session. For ongoing prospecting, schedule Duet to run the pipeline weekly, automatically refreshing your target list with new companies matching your ICP.
Learn more at [duet.so](/).
## Common Mistakes That Tank Response Rates
**Using company size as the only ICP filter.** Employee count correlates weakly with buying intent. Layer in funding, hiring, and tech stack signals.
**Sending emails immediately after enrichment.** Wait 2-3 days and check for job changes. 8-10% of enriched contacts switch roles within 90 days, sending to outdated contacts wastes deliverability.
**Personalizing with public LinkedIn activity.** Referencing someone's LinkedIn post feels stalky, not thoughtful. Stick to company-level signals (funding, hiring, product launches).
**Ignoring deliverability hygiene.** Sending 500 emails from a new domain tanks your reputation. Warm up domains gradually: 20/day for week 1, 50/day for week 2, 100+/day by week 3.
**Writing emails that sound helpful.** "I'd love to help you scale" is code for "I'm selling something." Lead with a specific observation, not an offer to help.
## Measuring What Actually Matters
Track three metrics weekly:
**Reply rate:** Percentage of emails that get any response. Target 15%+ for well-targeted campaigns. Under 10% indicates ICP or messaging problems.
**Meeting book rate:** Percentage of replies that convert to scheduled calls. Target 40-50%. Low conversion means your CTA is weak or your value prop isn't clear.
**Cost per meeting:** Total spend (tools + time) divided by meetings booked. Early-stage startups should aim for $50-150 per meeting. Above $200 suggests inefficient targeting.
Monitor deliverability separately. If open rates drop below 40%, you're hitting spam folders. Pause sending and warm up your domain.
Avoid vanity metrics like "emails sent" or "prospects enriched." Volume doesn't matter if reply rates are sub-5%.
## Frequently Asked Questions
### What's the difference between startup prospecting and freelancer prospecting?
Startup prospecting involves higher volumes (500-1,000 prospects per month vs. 50-100 for freelancers), team handoffs between prospecting and sales, CRM integration, and multi-touch sequences. Freelancers typically work smaller lists with more manual personalization. Startups need automation to generate pipeline at scale without dedicated SDR headcount.
### How much does an AI prospecting stack cost per month?
Expect $200-400 monthly for a full stack: $100-150 for enrichment (FullEnrich or Apollo), $50-100 for email sequencing (Lemlist or Instantly), and $50-150 for firmographic search (Crustdata or Harmonic). Add $100-200 if using AI models heavily for email generation. Total cost per meeting booked typically runs $50-150 for well-tuned campaigns.
### Can AI write emails that don't get flagged as spam?
Yes, if you provide specific context and avoid generic language. AI-generated emails trigger spam filters when they use templated phrases like "I'd love to help" or "reach out to learn more." Instead, prompt AI to reference specific company signals (recent funding, hiring, product launches) and write in a conversational tone. Combine this with proper domain warm-up and you'll maintain 40-60% open rates.
### Should I use Apollo or FullEnrich for contact enrichment?
Apollo works better for volume and cost ($0.10-0.20 per enriched contact) but has lower match rates (50-65%). FullEnrich costs more ($0.30-0.50 per contact) but searches 15+ data sources and hits 65-80% match rates. For early-stage startups optimizing for quality over volume, FullEnrich is worth the premium. For growth-stage teams running high-volume campaigns, Apollo's economics work better.
### How do I avoid sounding like every other AI-generated cold email?
Reference company-specific signals that require research, recent funding rounds, executive hires, product launches, tech stack changes, or hiring patterns. Generic AI emails say "I noticed you're growing fast." Specific emails say "Saw you hired 3 customer success reps in January right after your Series A, looks like you're bracing for serious onboarding volume." The difference is depth of context, not writing quality.
### What's a realistic reply rate for a first-time prospecting campaign?
First campaigns typically hit 8-12% reply rates as you dial in ICP fit and messaging. After 2-3 iterations, expect 15-20% for well-targeted B2B campaigns. Above 25% usually indicates very tight ICP alignment or strong inbound interest. Below 8% signals ICP or messaging problems, pause and refine before burning more prospects.
### How long does it take to set up an automated prospecting pipeline?
Initial setup takes 4-6 hours: define ICP (1 hour), build and enrich target list (2 hours), write and test email templates (1-2 hours), configure sequencing tool (1 hour). Once built, the pipeline runs continuously with ~2 hours of weekly maintenance to review replies, update targeting, and refresh prospect lists. Most startups fully automate prospecting within 2 weeks of starting.
---
Source: https://duet.so/blog/how-to-use-ai-as-personal-research-assistant
# How to Use AI as Your Personal Research Assistant
*Stop spending 8 hours on research that should take 20 minutes. Here's how to use AI as your personal research assistant. For sales, competitive analysis, and lead building.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 17 min read.
# How to Use AI as Your Personal Research Assistant
The bottleneck in most knowledge work isn't thinking. It's chasing information.
And before you roll your eyes at the "it's not X, it's Y" line… yeah, fair. It does sound like AI wrote it. That's kind of the joke.
Because most of the work happens before the thinking even begins.
Digging up decent sources, skimming endless tabs, cross-checking, stitching everything together, and only then getting to the part where you actually have something to say.
If you're lucky, that "real thinking" is 20% of the process. The rest is just… admin with extra steps.
AI flips that.
With the right setup, you can offload the messy middle, gathering, filtering, synthesizing.
And instead actually spend your time on the part that needs you: judgment, taste, decisions.
This guide breaks down what an AI research agent can actually handle on its own, where it still fumbles, how to set one up without overengineering it, and how to make sure you're not blindly trusting a very confident robot.
Quick Summary
This guide shows how to use AI as a personal research assistant. For market research, competitive analysis, news monitoring, and any topic you need to stay on top of, with an agent that continuously gathers, summarizes, and surfaces relevant information.
## What Does AI Research Actually Look Like in 2026?
Knowledge workers spend an average of 2.5 hours per day on information-gathering tasks. That's roughly a third of the working day spent on research before any real thinking can happen.
AI research agents have started to compress that dramatically. Sales teams running autonomous research workflows report cutting pre-call prep from 45 minutes to under 10.
Competitive analysts who used to spend a full day building a five-competitor report now get the same output in 30 minutes.
The shift isn't just about speed. It's about what becomes possible when research is no longer the bottleneck. Here's what that actually looks like in practice.
AI research is a multi-step autonomous process. Here's what happens when you ask an AI to "research this company":
1. Search: The AI queries multiple search engines for company name, domain, recent news
2. Scrape: It visits the company website, LinkedIn, Crunchbase, news articles
3. Extract: It pulls structured data - funding history, employee count, tech stack, recent announcements
4. Synthesize: It writes a formatted brief with all findings organized by category
5. Store: It saves all source data and context for follow-up questions
This is live web research happening in real time.
The difference from 2024-style "ChatGPT research" is autonomy.
You don't manually copy-paste URLs or summarize findings. You ask a question and come back to a complete report.
### Manual vs AI Research: Time Comparison
| Research Task | Manual Time | AI Time | Time Saved |
| --------------------------------------- | ----------- | --------- | ------------- |
| Company pre-call brief | 45-60 min | 8-12 min | 37-52 min |
| 5-competitor analysis | 6-8 hours | 25-35 min | 5.5-7.5 hours |
| 50-company lead list build + enrichment | 15-20 hours | 2-3 hours | 12-18 hours |
| Quarterly market landscape report | 2-3 weeks | 4-6 hours | 80-120 hours |
These numbers are from real agency and sales teams using autonomous AI research workflows.
## How to Research a Company Before a Sales Call
Sales reps spend 30-60 minutes before important calls reading the prospect's website, recent news, LinkedIn profiles, and funding history. AI can do this in 8 minutes.
### Pre-Call Company Research
1. Give the AI the company name or domain
Prompt: "Research Acme Corp (acmecorp.com) and prepare a sales brief. I need company overview, recent news, funding history, tech stack, and key decision makers."
2. The AI executes the research workflow
- Searches for company information across multiple sources
- Scrapes the company website for product details, messaging, case studies
- Checks Crunchbase or PitchBook for funding data
- Searches LinkedIn for employee count and key roles
- Searches news for recent announcements or press
3. Review the structured output
You receive a formatted brief in 8-12 minutes:
```
ACME CORP - SALES RESEARCH BRIEF
Generated: 2026-03-01
COMPANY OVERVIEW
- Industry: B2B SaaS, marketing analytics
- Founded: 2019
- HQ: Austin, TX
- Employees: 180-200 (per LinkedIn)
- Website: acmecorp.com
FUNDING HISTORY
- Series B: $28M (Dec 2024, led by Insight Partners)
- Series A: $12M (Mar 2023, led by Bessemer)
- Total raised: $42M
PRODUCT & POSITIONING
- Core product: Multi-channel attribution platform
- Target customer: Mid-market B2B companies ($10-100M ARR)
- Key messaging: "Attribution without the data science team"
- Pricing: Not public (contact sales model)
RECENT NEWS
- Feb 2026: Launched integration with HubSpot
- Jan 2026: Announced $28M Series B
- Dec 2025: Hired new VP Sales (John Smith, ex-Salesforce)
TECH STACK (detected)
- CRM: Salesforce
- Marketing: HubSpot, Google Ads
- Analytics: Segment, Amplitude
KEY DECISION MAKERS
- Sarah Johnson - CEO & Co-founder
- Michael Chen - VP Engineering
- John Smith - VP Sales
TALKING POINTS
- Recently raised Series B - likely expanding team
- HubSpot integration suggests HubSpot customer base is target
- Emphasis on "no data science team" = ease of use angle
- VP Sales is new hire from Salesforce - enterprise motion starting
```
4. Ask follow-up questions
Because the AI stored all research context, you can refine:
- "What are their main competitors?"
- "Pull recent LinkedIn posts from the CEO"
- "What integrations do they offer?"
No need to re-research. The AI already has the data.
### What This Replaces
The manual version meant opening 10-15 browser tabs, reading the website and About page, Googling funding history, manually checking Crunchbase, searching for recent news, looking up employees on LinkedIn, and copy-pasting notes into a doc before writing a summary from scratch. The whole process took 45-60 minutes per company, and that was before you even picked up the phone.
With AI research: 8-12 minutes, structured output, stored context for follow-ups.
## How to Analyze Competitors with AI
Competitive analysis is research-heavy. You need to compare features, pricing, positioning, messaging, customer reviews, and recent announcements across 5-10 competitors.
Manual competitive analysis takes 6-8 hours for 5 companies. AI does it in 25-35 minutes.
### Competitive Analysis
1. Provide the competitor list
Prompt: "Analyze these 5 competitors: CompanyA.com, CompanyB.com, CompanyC.com, CompanyD.com, CompanyE.com. For each one, pull: product overview, pricing, target customer, key features, and recent news. Then create a comparison table."
2. The AI researches each competitor
For each company, the AI:
- Scrapes the homepage, pricing page, features page
- Extracts product messaging and positioning
- Checks for pricing (if public)
- Searches recent news and press releases
- Looks for customer reviews on G2, Capterra, TrustRadius
This happens in parallel. All 5 companies researched simultaneously.
3. Get structured output
The AI returns:
- Individual briefs for each competitor
- A comparison table with features, pricing, positioning
- Analysis of market positioning and differentiation
- Gaps and opportunities
| Competitor | Target Customer | Pricing | Key Differentiator | Recent News |
| ---------- | --------------- | ------------------ | ---------------------- | ----------------------------------- |
| Company A | Enterprise | $2,500/mo starting | AI-powered insights | Series C $50M (Jan 2026) |
| Company B | Mid-market | $500-2,000/mo | Easy integration | Acquired by Oracle (Dec 2025) |
| Company C | SMB | $99/mo | Self-serve onboarding | New CEO hired (Feb 2026) |
| Company D | Enterprise | Custom pricing | White-glove service | Launched EU data centers (Mar 2026) |
| Company E | Developer-first | Open source + paid | API-first architecture | 10,000 GitHub stars milestone |
4. Ask for deeper analysis
- "Which competitors focus on ease of use vs power users?"
- "What pricing gaps exist in the market?"
- "Which competitor has the strongest enterprise messaging?"
### What This Replaces
Manual competitive research: visit each competitor website, screenshot features/pricing/messaging, search reviews on G2 and Capterra, search for recent news, copy-paste into a spreadsheet, write analysis. 6-8 hours for 5 competitors. AI research: 25-35 minutes.
## How to Build Lead Lists with AI Research
Lead list building is the most time-intensive research task. You need to find companies matching your ICP, enrich them with contact data, and qualify based on signals like funding, tech stack, or hiring.
Manual lead research: 15-20 hours for 50 qualified leads. AI research: 2-3 hours.
### Step-by-Step: AI Lead List Building
1. Define your ICP criteria
Prompt: "Find 50 B2B SaaS companies that match this profile: Series A or B funded, 50-200 employees, headquarters in US or UK, raised funding in last 18 months, using Salesforce as CRM. For each company, pull: name, domain, employee count, funding history, decision maker contacts."
2. The AI executes the search
- Searches Crunchbase, PitchBook, AngelList for companies matching funding + size criteria
- Filters by geography and tech stack
- Visits each company website
- Checks LinkedIn for employee count
- Identifies decision makers (by title: VP Sales, CRO, CEO)
3. Get the enriched lead list
Output is a structured CSV or table:
```
Company Name | Domain | Employees | Funding | Last Round | HQ | Tech Stack | Decision Maker | LinkedIn
Acme Corp | acme.com | 180 | $42M | Series B Dec 2024 | Austin TX | Salesforce, HubSpot | Sarah Johnson CEO | /sarah-j
Beta Inc | betainc.com | 95 | $18M | Series A Mar 2025 | London UK | Salesforce, Marketo | James Lee CRO | /james-lee
```
4. Qualify and prioritize
- "Which of these companies recently hired a VP Sales?" (expansion signal)
- "Which raised funding in last 6 months?" (budget signal)
- "Pull recent job postings for these companies" (hiring = growth)
## Why Research Persistence Matters
Here's the difference between "ChatGPT research" and an AI research assistant: persistence.
With ChatGPT, you ask a question, get an answer, close the tab, and start from scratch next time. There's no memory of what it found, no stored context, and no way to build on previous research sessions.
A persistent AI research assistant works differently. When you research a company or competitor, all findings are stored. Come back three days later and ask a follow-up. The AI still has the data.
This is critical for ongoing research workflows.
Example: You research a prospect company on Monday. On Thursday, you get a meeting. You ask "What were the key talking points for Acme Corp?" The AI instantly recalls the research from Monday. No re-research needed.
Or: You analyze 10 competitors in January. In March, you ask "Have any of our competitors launched new features since we last checked?" The AI knows what the landscape looked like in January and can diff the current state.
Persistence turns AI from a one-off answer machine into a research database that builds over time.
## The Research Workflow
AI research is not a single LLM call. It's a multi-step autonomous workflow. Here's what happens behind the scenes:
**Step 1: Query Planning**
The AI breaks down your research question into sub-tasks.
Example: "Research this company" becomes:
- Search for company domain and official website
- Scrape homepage and about page
- Search for funding data
- Search for recent news
- Search for decision makers on LinkedIn
**Step 2: Parallel Execution**
The AI executes these tasks in parallel. It doesn't wait for one to finish before starting the next. All searches, scrapes, and data pulls happen simultaneously. This is why AI research is 10-20x faster than manual.
**Step 3: Data Extraction and Structuring**
The AI parses unstructured web data into structured formats.
**Step 4: Synthesis and Formatting**
The AI writes a human-readable report, organized by category, with sources cited.
**Step 5: Storage**
All data is stored for follow-up queries. You never lose research context.
## How Duet Handles Research Workflows
Research requires three capabilities that most AI tools don't have: web access, persistent memory, and autonomous multi-step execution.
Duet is built for this. When you ask Duet to research a company or analyze competitors, it searches the web, scrapes pages, cross-references data, and synthesizes findings into a structured report. Because Duet runs on a persistent cloud server, all research context is stored. You can follow up days or weeks later and Duet still has the full dataset.
Example workflow: Ask Duet "Research these 5 competitors and create a comparison table." It searches each company, scrapes their sites, extracts pricing and features, and returns a formatted table. A week later, ask "Have any competitors launched new products?" Duet diffs the stored data against current state and surfaces changes.
This is the difference between ephemeral AI chat and a persistent research assistant. Learn more at [duet.so](/).
## Tools and Platforms for AI Research
Several platforms now offer AI research capabilities. Here's what to look for:
### Core Features for AI Research
1. **Web Search and Scraping** — The AI must be able to search the web and visit pages autonomously. Without this, it's limited to pre-trained knowledge (which is outdated).
2. **Multi-Step Workflows** — Research is not a single query. The AI should plan and execute 5-10 steps without requiring your input at each stage.
3. **Structured Output** — AI research should return tables, lists, and formatted reports, not just paragraphs of prose.
4. **Persistent Context** — The AI should store research findings so you can build on them over time.
5. **Source Citations** — Every data point should be traced back to a source URL. No hallucinated facts.
### Research-Focused AI Tools
- **Perplexity Pro**: Web search with citations. Good for quick research questions. No multi-step workflows or persistence.
- **Claude with web search**: Can search and synthesize. Limited to single-session context.
- **Duet**: Persistent AI server with web access, autonomous workflows, and long-term memory.
- **Custom research agents**: Built on LangChain or AutoGPT. High setup cost, full control.
For one-off questions, Perplexity works. For ongoing research workflows (competitive monitoring, lead research, market analysis), you need persistence and autonomy.
## Research Examples and Output Quality
### Example 1: Pre-Call Research Brief
Input: "Research Rippling.com and prepare a sales brief"
Output (8 minutes):
- Company overview: HR/payroll platform, 3,000+ customers, $1.35B valuation
- Funding: $700M total raised, last round May 2024
- Recent news: Launched international payroll in 15 countries (Feb 2026)
- Tech stack: Salesforce, Zendesk, Segment
- Decision makers: Parker Conrad (CEO), 3 VP-level contacts identified
### Example 2: Competitive Feature Comparison
Input: "Compare features for Notion, Coda, and Airtable"
Output (18 minutes):
| Feature | Notion | Coda | Airtable |
| ------------------ | ----------------------------------------------- | ---------------------------- | ----------------------------------------- |
| Database views | Table, board, calendar, gallery, timeline, list | Table, card, calendar, Gantt | Grid, calendar, gallery, Kanban, timeline |
| Formulas | Basic | Advanced (Python-based) | Advanced |
| API access | Yes, public | Yes, public | Yes, public |
| Automations | Native (limited) | Native (Packs system) | Native + Zapier |
| Mobile apps | iOS, Android | iOS, Android | iOS, Android |
| Offline mode | Yes | Limited | No |
| Pricing (starting) | $8/user/mo | $10/user/mo | $10/user/mo |
### Example 3: Lead List with Enrichment
Input: "Find 20 fintech startups in NYC, Series A funded, 30-100 employees"
Output (35 minutes):
- 20 companies with full enrichment: domain, funding, employee count, key contacts
- 3 companies flagged as "recently raised Series B" (expansion signal)
- 5 companies flagged as "hiring for VP Sales" (buying signal)
- CSV export ready for CRM import
## Common Mistakes When Using AI for Research
**Don't Skip Source Verification**
AI synthesises well but occasionally invents details, especially for funding figures or niche statistics. Always click through to the source URL before using data in a proposal, report, or client-facing document.
**Make Sure Your Tool Has Live Web Access**
Many AI tools are still running on 2024 knowledge cutoffs. If your tool doesn't have live web search built in, it's giving you stale data. Confirm it's actually pulling from the live web.
**Treat the First Output as a Draft**
Research is iterative. The first pass gives you structure and breadth. The follow-up questions are where the real insight comes from. Always push deeper after the initial output.
**AI Research Is 80-90% of the Work**
AI handles the gathering, structuring, and initial synthesis. The remaining 10-20%, judgment calls, reading between the lines, deciding what's strategically important, still needs you.
**Stop Re-Researching the Same Companies**
If you research the same market, competitors, or prospect list more than once, use an AI tool with persistent memory. Every time you start fresh, you're throwing away work you already paid to have done.
## How to Get Started with AI Research Today
**Step 1: Pick one repetitive research task**
Don't try to automate everything at once. Pick the research task you do most often: pre-call company research, competitive analysis, or lead list building.
**Step 2: Write a clear prompt**
Define exactly what data you need. Example: "Research [company name]. Pull: company overview, funding history, employee count, tech stack, recent news, and key decision makers."
**Step 3: Test with 3-5 examples**
Run the AI research on 3-5 companies or competitors. Compare output quality to your manual process.
**Step 4: Refine the prompt**
If the AI misses data you need, add it to the prompt. If it returns too much irrelevant info, narrow the scope.
**Step 5: Build it into your workflow**
Once you're confident in output quality, make AI research your default. Don't manually research first.
**Step 6: Set up persistence**
If you research the same market or competitors over time, use an AI tool with persistent memory so you're building a knowledge base, not starting from scratch each time.
## Frequently Asked Questions
### What is an AI research assistant?
An AI research assistant is an AI agent with web access that autonomously searches, scrapes, and synthesizes information from the internet. Unlike a standard chatbot, it executes multi-step research workflows without requiring human input at each stage. You ask a research question, and it returns a structured report with sources cited.
### How is AI research different from using ChatGPT?
ChatGPT has a knowledge cutoff and doesn't access live web data unless you use a plugin. AI research assistants search the web in real time, scrape current pages, and store research context across sessions. They're built for ongoing research workflows, not one-off questions.
### Can AI research tools access private company data?
No. AI research tools only access publicly available information: company websites, press releases, LinkedIn, Crunchbase, G2 reviews, and news articles. They can't access private databases, financials, or customer lists unless that data is published online.
### How accurate is AI research compared to manual research?
AI research is 85-95% accurate for factual data (funding, employee count, product features). The main risk is outdated information or hallucinated details. Always verify sources, especially for critical decisions. AI is best used as a research draft that you review and refine.
### What types of research can AI automate?
AI excels at data-gathering tasks: competitive analysis, market sizing, lead list building, company research, pricing comparisons, technology stack detection, and news monitoring. It's less effective for qualitative research requiring human judgment like customer interviews or brand perception analysis.
### Do I need technical skills to use AI for research?
No. Most AI research tools are chat-based. You ask questions in plain English, and the AI executes the workflow. No coding required. For advanced use cases like custom research agents or automated monitoring, technical setup helps but isn't required.
### How much does AI research cost compared to hiring a researcher?
A junior researcher costs $40-60K/year salary or $25-50/hour freelance. AI research tools cost $20-100/month for unlimited research. Time savings are 10-20x. For a sales or marketing team running research daily, ROI is reached in the first week.
---
Source: https://duet.so/blog/how-to-use-ai-for-market-research-before-launch
# How to Use AI for Market Research Before Launch
*Validate your idea before you build it. Use AI to run market research that would normally cost $10K and 3 months.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 12 min read.
# How to Use AI to Do Market Research Before Launching a Product
Startup founders nowadays do one of two things before launching.
They either skip market research entirely ('we'll learn from customers') or they spend three months on a 40-page research doc that gets ignored the moment they start building.
Neither approach is particularly useful.
The right answer is targeted, fast market research that answers the specific questions you need answered before committing resources.
AI makes this possible in hours rather than weeks, competitor analysis, market sizing, demand validation, customer language mining, all without a research team or expensive tools.
This blog covers what to research, how to do it with AI, and how to interpret the output without fooling yourself.
Quick Summary
This guide covers how to use AI for market research before launching a product. Validating demand, sizing the market, analyzing competitors, and identifying your ideal customer, condensing weeks of research into hours.
Questions this page answers
- How to use AI for market research before launch
- Best AI tools for startup market research
- Can AI replace traditional market research?
- How to validate a startup idea with AI
- What market research can AI automate?
## Why Most Solopreneurs Skip Market Research
Market research takes 10-20 hours of manual work. You need to visit dozens of competitor sites, screenshot pricing tables, read hundreds of reviews, export keyword data, and compile everything into a coherent analysis.
Most solo founders skip this step entirely. They build for 3-6 months, launch to crickets, then discover the market was saturated or the problem wasn't painful enough to pay for.
The cost of skipping validation is 3-6 months of wasted development time. The alternative paying a research firm $5,000-15,000 isn't realistic for pre-revenue founders.
## How AI Turns 2 Weeks of Research Into 2 Hours
AI automates the four components of product validation:
1. Competitor identification and feature extraction - AI scrapes competitor sites and structures their offerings into comparable tables
1. Pricing and positioning analysis - AI extracts pricing tiers, calculates average market rates, and identifies positioning patterns
1. Demand validation - AI pulls keyword search volumes and trend data to quantify market size
1. Gap analysis - AI synthesizes findings to identify underserved segments and feature gaps
Each step used to require manual data collection and spreadsheet work. AI handles collection, structuring, and initial analysis automatically.
## Step 1: Define Your Market and Identify Competitors
Start by defining your target market in one sentence. Example: "Project management tools for remote software teams under 20 people."
Use AI to generate a competitor list. Ask it to identify:
- Direct competitors (same solution, same audience)
- Adjacent competitors (same solution, different audience)
- Alternative solutions (different approach, same outcome)
You should end up with 15-25 competitors across these three categories. This gives you comprehensive market coverage without drowning in data.
Sample prompt:
```plaintext
I'm launching [product description]. Identify 20 direct and adjacent competitors.
For each, provide: company name, URL, target customer, primary use case,
approximate company size.
```
AI pulls this from multiple sources: G2, Capterra, Product Hunt, Crunchbase, and search results. You get a structured list in 2-3 minutes instead of spending 2 hours manually searching and note-taking.
## Step 2: Scrape Competitor Pricing and Features
Use web scraping tools to extract structured data from competitor sites. Firecrawl and similar AI-powered scrapers can navigate pricing pages, extract table data, and structure it into comparable formats.
For each competitor, scrape:
- Pricing tiers and limits
- Core features by tier
- Add-on pricing
- Free trial details
- Annual vs monthly pricing
What you learn from pricing data:
The median price point tells you what customers expect to pay. If 80% of competitors charge $49-99/month for your target tier, pricing at $199/month requires exceptional differentiation.
Feature distribution shows which capabilities are table stakes vs premium. If every competitor includes API access in their base tier, you can't charge extra for it.
## Step 3: Analyze Review Sentiment and Pain Points
Pull reviews from G2, Trustpilot, Capterra, and Reddit. You need 200-500 reviews across your competitor set to identify patterns.
AI can process this volume in minutes. It categorizes feedback into:
1. Feature requests - What users wish the product did
1. Frustration points - What makes users consider switching
1. Praise patterns - What users love and won't leave for
1. Use case mentions - How people actually use the product
Review analysis prompt template:
```plaintext
Analyze these 300 reviews for [competitor]. Extract:
1. Top 10 feature requests (with frequency)
2. Top 5 complaints (with severity and frequency)
3. Most praised aspects (with frequency)
4. Mentioned use cases and workflows
Present as structured data.
```
The gap between feature requests and current offerings is your opportunity map. If 40% of users request native time tracking and no competitor offers it, that's a validated market gap.
## Step 4: Validate Demand With Keyword and Search Data
Use keyword research APIs (DataForSEO, SEMrush API) to quantify search demand. You need three numbers:
1. Problem-aware searches - "how to manage remote team projects" (10,000/month)
1. Solution-aware searches - "project management software" (50,000/month)
1. Product-specific searches - "[competitor name]" volumes (sum of top 5 competitors)
If problem-aware searches are under 1,000/month, the pain point isn't widespread enough. If solution-aware searches are under 5,000/month, the market is too small for venture-scale businesses.
Minimum viable search volumes for different business models:
Competitor brand search volumes tell you market maturity. If the top competitor gets 100,000 brand searches per month, there's established demand. If the top 5 competitors combined get under 5,000, the category is pre-awareness.
## Step 5: Identify Market Gaps and Positioning Opportunities
Synthesize your data into a competitive landscape analysis. Create a positioning map with two axes:
- X-axis: Price (low to high)
- Y-axis: Target customer (SMB to Enterprise)
Plot your competitors. Look for empty quadrants.
Example gap analysis:
```plaintext
Market: Project management for remote teams
Competitors mapped: 18 tools
Gap identified: No affordable ($20-40/month) option purpose-built for
async-first teams. Current options:
- Asana/Monday: $40-80/month, built for synchronous teams
- ClickUp: $35/month, feature bloat overwhelms small teams
- Basecamp: $99/month flat, too expensive for 5-person teams
Opportunity: Async-optimized project management at $29/month for
teams under 15 people.
```
This gap is validated by:
- 12% of reviews mention "too expensive for small teams"
- 23% mention "too complex" or "feature overload"
- Zero competitors explicitly position for async teams
- "async project management" gets 2,400 searches/month
## Building a Competitive Landscape Report Automatically
Structure your findings into a reusable report template. AI can generate this from your scraped data and analysis.
Report sections:
1. Executive Summary (3-5 bullet points)
1. Market Size and Trends (search volumes, growth rates)
1. Competitor Matrix (pricing, features, positioning)
1. Gap Analysis (underserved segments and feature opportunities)
1. Positioning Recommendation (where you should play)
1. Next Steps (features to prioritize, pricing strategy, go-to-market approach)
Save this as a living document. Re-run the analysis monthly to track competitor moves and market evolution.
## Using AI to Orchestrate the Full Research Workflow
The manual version of this research requires:
- 4 hours scraping competitor sites
- 3 hours organizing pricing and feature data
- 5 hours reading and categorizing reviews
- 2 hours pulling and analyzing keyword data
- 4 hours synthesizing into a report
Total: 18 hours spread over 5-7 days.
The automated version:
Tools like Duet let you run this entire workflow from a single conversation. You describe what you're researching, and AI coordinates web scraping (via Firecrawl), keyword research (via DataForSEO), review analysis, and report generation.
The workflow runs on a persistent server that keeps your data and code. You can ask it to refresh competitor pricing weekly, alert you to new product launches in your space, or re-analyze reviews monthly to spot emerging trends.
Instead of 18 hours of manual work, you spend 30 minutes defining what you want to research and reviewing the output. The AI handles scraping, structuring, analysis, and reporting.
This matters because market research shouldn't be a one-time pre-launch exercise. Continuous competitive intelligence is what keeps you ahead as the market evolves. Learn more about automating competitive intelligence workflows.
## Validating Demand Beyond Keywords
Search volume is a lagging indicator. By the time people search for a solution, competitors are already established. Look for leading indicators:
Social listening signals:
- Reddit posts asking "how do you [solve problem]?" with 50+ upvotes
- Twitter threads complaining about existing solutions
- LinkedIn discussions in your target customer segment
- Niche community forums (Indie Hackers, specific Slack/Discord groups)
Proxy metrics:
- Adjacent tool adoption rates
- Funding announcements in your category
- Job posting trends for roles that would use your product
- Podcast and content mentions of the problem space
If you see 20+ highly-engaged social conversations about the problem in the last 90 days, demand exists even if keyword volume is low. The market is pre-awareness, which is an opportunity for category creation.
## Common Market Research Mistakes to Avoid
Mistake 1: Researching competitors, ignoring customers
Competitor features tell you what's been built, not what customers actually need. Spend equal time on review analysis and customer interviews.
Mistake 2: Only looking at direct competitors
Users switch from adjacent solutions and manual processes, not just direct competitors. Research the full "jobs to be done" landscape.
Mistake 3: Treating research as a one-time exercise
Markets evolve. A validated gap in January can become saturated by June. Set up automated monitoring so you catch competitor launches and pricing changes.
Mistake 4: Confusing search volume with willingness to pay
High search volume for "free project management tool" doesn't validate a paid product. Segment keyword intent (free vs paid, SMB vs enterprise).
Mistake 5: Ignoring market maturity
Early markets (low competitor count, low search volume) require customer education budgets. Mature markets require differentiation budgets. Your go-to-market cost structure depends on which market you're entering.
## Turning Research Into a Launch Decision
Your research should answer five questions:
1. Is the market big enough? (Minimum 5,000 solution-aware searches/month for bootstrap SaaS)
1. Is there a clear gap? (Underserved segment or missing features with validated demand)
1. Can you reach customers affordably? (Clear distribution channels with known CAC benchmarks)
1. Is willingness to pay proven? (Competitors successfully charging in your target price range)
1. Do you have an unfair advantage? (Technical, distribution, or insight edge that prevents fast-follow competition)
If you answer yes to 4 out of 5, the market is validated. If you answer yes to 3 or fewer, you're guessing.
The research workflow outlined above gives you data to answer these questions in 2-3 hours instead of 2-3 weeks. Speed matters because markets move quickly and your opportunity cost is building the wrong thing.
For more on using AI to accelerate research tasks, see how to use AI as your personal research assistant and how to scrape, analyze, and monitor any website.
## Frequently Asked Questions
### What's the minimum viable market research for a product launch?
At minimum, you need competitor pricing data (10-15 competitors), demand validation (keyword volumes for 5-10 core terms), and qualitative validation (50-100 competitor reviews analyzed). This takes 2-3 hours with AI automation and gives you enough data to make a launch decision. Skip any of these three and you're guessing on critical assumptions.
### How do I know if a market gap is real or just underserved for a reason?
Real gaps have evidence of customer demand (review requests, search volume, social discussions) but no adequate solution. False gaps exist because the economics don't work (too expensive to serve, low willingness to pay) or the problem isn't actually painful (nice-to-have, not must-have). Validate by looking for workarounds—if users build manual processes or chain together 3 tools to solve it, the pain is real.
### Can AI replace customer interviews in market research?
No. AI can process existing data at scale (reviews, support tickets, social posts) to identify patterns, but it can't ask follow-up questions or validate novel hypotheses. Use AI to screen for patterns and prioritize who to interview, then do 10-15 customer conversations to validate your interpretation and uncover unstated needs.
### How often should I re-run competitive research after launching?
Monthly for fast-moving markets (developer tools, AI products, social platforms), quarterly for moderate-pace markets (B2B SaaS, productivity tools), semi-annually for slow-moving markets (enterprise infrastructure, regulated industries). Set up automated alerts for competitor pricing changes and new product launches so you don't miss important moves between research cycles.
### What tools do I need to automate market research with AI?
You need web scraping (Firecrawl, Apify), keyword research APIs (DataForSEO, SEMrush API), review aggregation (G2/Capterra APIs or scrapers), and an AI orchestration layer to coordinate the workflow and analyze results. Platforms like Duet bundle these capabilities into a conversational interface. Alternatively, use Claude Code to script the workflow yourself.
### How do I validate demand in a pre-awareness market with low search volume?
Look for proxy signals: adjacent tool adoption rates, problem discussions in communities (Reddit, niche Slack/Discord groups), workaround complexity (if users chain together 3+ tools, pain is validated), and funding/hiring trends in the space. Interview 20-30 target customers to validate problem severity. Pre-awareness markets require customer education budgets—factor 2-3x higher CAC into your unit economics.
### What's the difference between competitor analysis and market research?
Competitor analysis focuses on existing solutions: their features, pricing, positioning, and customer feedback. Market research focuses on customer needs, market size, buying behavior, and willingness to pay. You need both. Competitor-only research risks building a better version of something no one wants. Customer-only research risks ignoring what's already been tried and failed.
---
Source: https://duet.so/blog/how-to-use-ai-to-find-prospects-for-freelance-business
# Use AI to Find High-Intent Freelance Prospects
*Stop chasing cold leads. Use AI to find freelance prospects who already need what you offer, and reach them first.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 12 min read.
# How to Use AI to Find High-Intent Prospects for Your Freelance Business
The hardest part of freelancing is finding clients who are ready to buy right now.
Most freelance prospecting is a numbers game played with low-intent targets.
AI makes this practical at scale, scanning job boards, community posts, company announcements, and social signals to surface the prospects who are actually in buying mode right now.
You can use AI to find high-intent prospects by combining web scraping, lead enrichment, and automated outreach into a single pipeline that runs on a cloud server.
Instead of manually searching LinkedIn and cold-emailing blind, AI identifies companies actively looking for your services, finds the right decision-maker, and drafts a personalized email all in under 30 minutes for a batch of 50 leads.
This guide walks through the exact workflow, step by step.
Quick Summary
This guide shows how to use AI to find high-intent freelance prospects, building a system that identifies potential clients actively looking for the services you offer, so your outreach is targeted and your conversion rates are higher.
Questions this page answers
- How to find freelance clients with AI
- Best AI tools for freelance prospecting
- How to use AI to find high-intent freelance leads
- Can AI automate freelance client outreach?
- How to build an AI prospecting system for freelancers?
---
## Why Traditional Prospecting Doesn't Work for Freelancers
Most freelancers find clients through one of three channels: referrals, job boards, or cold outreach. All three have the same problem they don't scale without burning your time.
Referrals are great when they come, but you can't control the volume. One month you're turning down work, the next you're scrambling. Job boards (Upwork, Toptal, Freelancer.com) force you into a race-to-the-bottom pricing war where you compete against hundreds of proposals. Cold outreach works, but manually researching companies, finding emails, and writing personalized messages takes 10-15 hours per week to generate a handful of conversations.
The math is brutal: if you spend 12 hours a week on prospecting, that's 48 hours a month you're not billing. At $150/hour, that's $7,200 in lost revenue just to keep your pipeline full.
AI flips this equation. The research, enrichment, and drafting that used to take hours happens in minutes — and it can run while you sleep.
---
Finding leads is only valuable if the outreach converts, here's how to close the loop.
## What "High-Intent" Actually Means (and Where to Find Signals)
Not all prospects are equal. A "high-intent" prospect is a company that's actively signaling they need what you offer right now, not someday.
### Intent Signals to Look For
- Job postings for the role you replace: A startup posting "looking for a freelance designer" or "contract data analyst needed" is a direct signal. But even postings for full-time roles in your area signal budget and need.
- Tech stack changes: Companies adopting new tools in your domain (migrating to a new CMS, switching analytics platforms, launching a new product line) often need outside help during transitions.
- Funding events: Companies that just raised a seed or Series A round have cash to spend and projects to ship. The 3-month window after a funding announcement is the highest-conversion period.
- Content signals: Companies publishing blog posts about challenges you solve ("Why we're rebuilding our data pipeline") are telling you what they need.
- Hiring surge without fill: A company that's been posting the same role for 60+ days is struggling to hire full-time and may be open to a contractor.
### Where These Signals Live
The key insight: all of these sources are publicly available and scrapable. You don't need expensive sales intelligence platforms you need a web scraper, an enrichment API, and some AI to connect the dots.
---
## The AI Prospecting Workflow: 5 Steps
Here's the complete pipeline from "I need clients" to "personalized emails in their inbox."
### Step 1: Define Your Ideal Client Profile (ICP)
Before you scrape anything, write down exactly who you're looking for. Be specific:
- Company size: 10-100 employees (big enough to have budget, small enough to need contractors)
- Industry: B2B SaaS, fintech, healthtech whatever your niche is
- Stage: Seed to Series B (funded, growing, shipping features)
- Geography: US, remote-friendly (or wherever you target)
- Role to contact: VP of Engineering, Head of Design, CTO, Marketing Director — whoever hires freelancers like you
Write this down as a filtering checklist. Every prospect either passes or doesn't.
### Step 2: Scrape for Intent Signals
Now use web scraping to pull raw prospect data from multiple sources simultaneously.
Job board scraping:
Scrape job boards for postings that match your skill set. For a freelance developer, you might search for "freelance React developer" or "contract frontend engineer" across LinkedIn Jobs, Indeed, AngelList, and WeWorkRemotely.
The scraper pulls: company name, job title, posting date, description text, and company URL.
Funding event scraping:
Scrape TechCrunch, Crunchbase, or other funding databases for companies that raised in the last 90 days within your target industry. Pull: company name, amount raised, round type, investors, and company URL.
Company blog/news scraping:
For companies already on your radar, scrape their blog or news page for recent posts signaling projects in your domain.
The output of this step is a raw list of 100-200 company names with context on why they appeared (what signal triggered the match).
### Step 3: Enrich the Data
Raw company names aren't enough. You need firmographic data to filter and contact information to reach out.
Company enrichment pulls:
- Employee count
- Industry classification
- Tech stack (what tools they use)
- Revenue range
- Location and remote policy
- Recent LinkedIn posts from the company
Contact enrichment finds:
- The decision-maker's name and title
- Verified work email address
- LinkedIn profile URL
- Recent activity or posts
This is where APIs like Crustdata (for company and people data) and FullEnrich (for verified email addresses) are essential. You feed in the company name or domain, and get back structured data.
Apply your ICP filter from Step 1 here. Of your 200 raw companies, maybe 50-80 pass the filter. Of those, you find verified emails for 40-60 contacts.
### Step 4: Generate Personalized Outreach
This is where most AI-powered prospecting falls flat people use AI to write generic templates and wonder why they get zero replies.
The secret: feed the AI all the enrichment data before it writes.
For each prospect, the AI should know:
- What the company does
- Why they appeared in your search (the intent signal)
- The contact's role and background
- The company's current tech stack
- Any recent news, funding, or hiring activity
With that context, AI can write an email that references specific details:
> "Saw you just raised your Series A congrats. I noticed you're hiring for a senior frontend role and your job post mentions migrating from Angular to React. I've done exactly that migration for three other B2B SaaS companies this year..."
That email gets replies. A generic "I'm a freelance developer and I'd love to help" does not.
Batch this: Generate personalized emails for all 50 qualified prospects in a single run. Review them in bulk (5 minutes to scan 50 emails and tweak 3-4 that need adjustment), then queue them for sending.
### Step 5: Automate and Repeat
The real power isn't running this once it's running it automatically on a schedule.
Set up a recurring task that:
1. Scrapes job boards and funding databases every week
1. Enriches new companies that match your ICP
1. Finds contact information for decision-makers
1. Drafts personalized emails
1. Saves them for your review before sending
You review the batch once a week (15 minutes), approve the emails that look good, and your pipeline stays full without daily grind.
---
## Example: 50 Qualified Leads in 30 Minutes
Here's what this looks like in practice for a freelance UX designer targeting funded B2B SaaS startups:
Minute 0-5: AI scrapes recent Crunchbase entries for B2B SaaS companies that raised Seed or Series A rounds in the last 60 days. Pulls 87 companies.
Minute 5-10: Company enrichment filters to 10-200 employees, US-based or remote-friendly. 52 companies pass.
Minute 10-15: Contact search finds Head of Design, VP Product, or CEO for each company. Verified email found for 48 contacts.
Minute 15-25: AI drafts personalized emails for all 48, each referencing the company's product, funding round, and a relevant portfolio piece.
Minute 25-30: You review the batch. Tweak 5 emails, delete 3 that don't feel right, approve the remaining 40.
Result: 40 personalized, research-backed outreach emails ready to send. If even 5% convert to calls, that's 2 new client conversations per week from 30 minutes of work.
Over a month, that's 8 sales calls from 2 hours of effort. Compare that to the 48+ hours most freelancers spend on prospecting.
---
## How to Run This Pipeline 24/7 on a Cloud Server
Everything described above can run on your laptop but it stops when you close your laptop. The prospecting pipeline works best when it's always on:
- Scheduled scraping runs at 6am every Monday, pulling fresh intent signals before your work week starts
- Enrichment runs automatically on any new companies found
- Email drafts are waiting in your inbox when you sit down Monday morning
- Competitor monitoring catches changes to rival agencies' client lists in real-time
This is where a persistent cloud server changes the game. Instead of running scripts locally, your AI agent lives on a server that's always on like having OpenClaw running in the cloud, but without the security concerns of self-hosting and without the interruption of closing your laptop.
Platforms like Duet give you exactly this: a private cloud server with an AI agent pre-installed. You describe your prospecting workflow in a durable session, and the agent sets up the scraping, enrichment, email drafting, and scheduling. It accumulates context about your business over time and keeps the resulting data and reports in the workspace.
The server can also:
- Receive web hooks trigger prospecting when a new lead fills out a form on your site
- Host a dashboard simple web app showing your pipeline and draft emails, accessible from your phone
- Run multiple workflows prospecting, competitive monitoring, and client research all running in parallel
---
## Common Mistakes to Avoid
Skipping enrichment and going straight to outreach. The enrichment step is what separates a 2% reply rate from a 15% reply rate. Never email someone without knowing their company, role, and recent context.
Scraping too broadly. If your target list is 500 companies, your ICP isn't specific enough. The best prospecting targets 50-100 companies per cycle with tight filters.
Sending AI-written emails without review. AI drafts should be your starting point, not your final output. Spend 15 minutes reviewing and tweaking. Your voice matters the AI provides the research, you provide the personality.
Running this once and expecting results. Prospecting is a compounding activity. Week 1 might generate 1 call. By week 4, you have 4 parallel conversations. By week 8, you're choosing which clients to take. The automation only pays off if it runs consistently.
Using outdated data. Intent signals decay fast. A job posting from 3 months ago is worthless. A funding round from last week is gold. Run your scraping weekly at minimum.
---
## Frequently Asked Questions
### How much does it cost to run an AI prospecting pipeline?
The main costs are enrichment API credits and your AI platform. Enrichment typically costs $0.05-0.50 per contact depending on the provider. For 50 leads per week, expect $10-25/month in enrichment costs plus your AI platform subscription. Compare that to a virtual assistant at $500-1,500/month or a sales development tool at $200-500/month.
### Do I need to know how to code to set this up?
No. Modern AI agent platforms let you describe what you want in plain English. You say "find B2B SaaS companies that raised seed rounds in the last 90 days, find the head of product's email, and draft a personalized outreach email" and the AI handles the scraping, API calls, and email generation.
### Is web scraping legal?
Scraping publicly available data (job postings, company websites, press releases) is generally legal in the US under the hiQ Labs v. LinkedIn precedent. However, you should respect robots.txt, avoid scraping behind logins, and comply with GDPR if targeting EU contacts. Never scrape private or gated content.
### What reply rate should I expect?
Cold email benchmarks for personalized, research-backed outreach are 5-15% reply rates. If you're below 5%, your personalization isn't specific enough. If you're above 15%, you've found a great niche — double down.
### How is this different from using LinkedIn Sales Navigator or Apollo.io?
Those tools are databases with filters. This approach is fundamentally different — it starts with intent signals (who needs help right now?) rather than static attributes (who matches my ICP?). You're not searching a database; you're monitoring the web for real-time buying signals and then enriching those leads. The result is much higher intent and conversion.
### Can I use this for agency lead generation too?
Absolutely. The workflow is identical just adjust your ICP filters and email templates. Agencies can run parallel prospecting for different service lines (SEO clients, design clients, development clients) on the same server.
### How long before I see results?
Expect 2-4 weeks to see your first meetings from this pipeline. The first week is setup and calibration (refining your ICP, testing email messaging). By week 2-3, you'll have your first conversations. By month 2, the pipeline should be consistently generating 4-8 qualified conversations per month.
---
---
Source: https://duet.so/blog/how-to-use-ai-to-run-startup-operations-with-a-3-person-team
# Use AI to Run Startup Ops with a 3-Person Team
*Three people, ten people's worth of ops. Here's how a small startup team uses AI to run operations without burning out or hiring.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 12 min read.
At three people, you're doing everything.
Somebody's the CEO, the product manager, and the one who figures out why the invoices aren't going out. Operations work expands to fill whatever time you let it, and at a tiny team, that's a tax you really can't afford.
The good news: a surprising amount of early-stage ops is repetitive and rule-based. Meeting coordination, standup summaries, investor updates, onboarding checklists, weekly reports, these follow predictable patterns. And predictable patterns are exactly what AI is good at.
This guide is the playbook for a 3-person startup that wants to operate like a 10-person team without burning out or hiring.
**Quick Summary**
This guide shows how a 3-person startup team can use AI to run operations that would normally require 10+ people, covering ops, GTM, engineering, and support with AI agents that let your small team ship like a much larger one.
**Questions this page answers**
- How to run startup ops with a small team using AI
- Best AI tools for startup operations
- How can a 3-person team operate like a larger company with AI?
- What ops can AI handle for a startup team?
- How to ship more without adding headcount?
## Operations AI Should Handle
AI should handle repeatable, data-driven tasks that don't require human judgment or relationship building.
High-value automation targets for a 3-person startup include: Meeting scheduling and calendar coordination, Daily standup summaries and status updates, Weekly investor update generation from metrics, Hiring pipeline tracking and candidate outreach. Also: Customer onboarding email sequences, Invoice processing and expense categorization, Support ticket routing and initial responses. These are all tasks that follow a consistent pattern and don't require strategic judgment, exactly the kind of work AI handles well.
Reserve human time for strategic decisions, investor calls, customer discovery interviews, and culture building. A 3-person team has roughly 120 hours per week of capacity. AI can reclaim 30-40 hours by handling the operational layer.
## Operations Mapping by Humans vs AI
Use a simple decision matrix: repetition frequency, judgment requirement, and relationship sensitivity.
| Task Type | Example | Best Handler |
| -------------------------------- | ---------------------------------------- | -------------------- |
| High repetition, low judgment | Meeting scheduling, standup summaries | AI automation |
| High repetition, medium judgment | Support ticket routing | AI with human review |
| Low repetition, high judgment | Strategic planning, fundraising | Human only |
| Any task requiring trust | Customer success calls, investor updates | Human with AI prep |
Start by tracking every task for one week. Note how often it repeats, whether it follows a template, and if it requires relationship context. Tasks that repeat 3+ times per week and follow a pattern are prime automation candidates.
For a typical operations person's workload, 60-70% usually qualifies for automation. The remaining 30-40% involves exceptions, edge cases, and relationship-sensitive work that needs human touch.
## Automated meeting scheduling
Meeting scheduling consumes 2-4 hours per week for early-stage teams. Automate it completely.
Setup steps:
1. Connect your calendar API (Google Calendar, Outlook) to your automation platform
1. Create availability rules: working hours, buffer time between meetings, blackout periods
1. Set up a natural language interface that understands "schedule a 30-minute call next week"
1. Configure calendar invite templates with Zoom links, agenda placeholders, and reminder timing
1. Add context awareness so the system knows meeting types (investor, customer, recruiting)
Example automation flow:
When someone sends "schedule a demo with Acme Corp next Tuesday," the AI:
- Checks both calendars for Tuesday availability
- Proposes 3 time slots based on preferences
- Sends calendar invites with Zoom link and demo agenda
- Adds the company to your CRM with "demo scheduled" status
- Sets a reminder to prep the demo deck 2 hours before
Time saved: 15-20 minutes per meeting scheduled. At 10 meetings per week, that's 3+ hours reclaimed.
## Daily standup summaries
Daily standups keep teams aligned but meetings are time sinks. Async standups via AI cut 30 minutes per day.
Setup steps:
1. Create a scheduled automation that runs every morning at 9 AM
1. Configure it to pull updates from project management tools (Linear, GitHub, Notion)
1. Set up a prompt template: "What shipped yesterday, what's in progress, what's blocked"
1. Route the summary to your team channel (Slack, Teams, or your internal chat)
1. Add interactive elements so team members can flag blockers or add context
Example output:
```plaintext
Daily Standup - March 1, 2026
Shipped Yesterday:
- Payment integration (Sarah) - merged to staging
- Landing page redesign (Tom) - live on production
- 3 customer onboarding calls completed
In Progress:
- API v2 documentation (Sarah) - 60% complete
- Hiring pipeline - 5 candidates in final round
Blocked:
- None reported
Reply with any updates or blockers.
```
This runs every morning without human input. Team members see progress, blockers get surfaced, and you save 30 minutes of meeting time daily.
Related reading: How to Set Up a 24/7 AI Agent covers scheduling and automation patterns.
## Automated investor update generation
Investor updates take 2-3 hours to write monthly. AI can generate 80% of the content from your metrics.
Setup steps:
1. Connect data sources: Stripe for revenue, Google Analytics for traffic, your CRM for pipeline
1. Create a monthly schedule (first Monday of each month)
1. Build a template: key metrics, wins, challenges, asks
1. Configure the AI to pull last 30 days of data and calculate month-over-month changes
1. Set up a draft review workflow so the founder reviews before sending
Example generated update:
```plaintext
February 2026 Update
Key Metrics:
- MRR: $47K (↑22% MoM)
- New customers: 14 (↑40% MoM)
- Churn: 2.1% (↓0.8% MoM)
- Runway: 14 months
Wins:
- Closed Series Seed ($2M, led by Acme Ventures)
- Shipped API v2 with 3 launch partners
- Featured in TechCrunch
Challenges:
- Sales cycle lengthening (avg 45 days, up from 30)
- Engineering hiring slower than planned
Asks:
- Intros to VP Eng candidates (10+ years, B2B SaaS)
- Beta customers in fintech vertical
```
The founder reviews, adds color commentary, and sends. Total time: 20-30 minutes instead of 2-3 hours.
## Hiring pipeline tracking
Recruiting coordination is pure operations overhead. Automate candidate tracking and outreach.
Setup steps:
1. Create a hiring pipeline database with stages: sourced, reached out, screening, interview, offer
1. Set up automated outreach sequences for sourced candidates
1. Configure interview scheduling automation (connects to calendars)
1. Build weekly pipeline summaries that show funnel metrics
1. Add trigger-based automations: when candidate moves to "interview," send prep materials
Example weekly summary:
```plaintext
Hiring Pipeline - Week of March 1
Engineering:
- Sourced: 12 new candidates
- Screening: 5 calls scheduled
- Interview: 2 onsites this week
- Offer: 1 pending (Sarah Chen, expected response Monday)
Conversion rates:
- Sourced → Screen: 15% (target: 20%)
- Screen → Interview: 40% (target: 30%)
- Interview → Offer: 50% (on target)
Action items:
- Follow up with 3 screening candidates who haven't responded
- Schedule onsite for candidate #247
```
This level of tracking would require a dedicated recruiting coordinator. With automation, it runs itself and flags what needs human attention.
Related reading: How to Build and Ship an Internal Tool in a Day Using AI covers building custom tools for tracking.
## How do you set up "always-on" automations?
Always-on automations run without human intervention on schedules, triggers, or events.
Three automation patterns:
### 1. Cron-scheduled tasks
Run on a fixed schedule. Examples: daily standups at 9 AM, weekly metrics summaries on Monday, monthly investor updates on the 1st.
### 2. Webhook-triggered tasks
Run when an event occurs. Examples: new form submission triggers lead research, new hire triggers onboarding sequence, support ticket triggers initial response.
### 3. Message-triggered tasks
Run when someone asks. Examples: "generate a sales deck for Acme Corp," "summarize last week's customer feedback," "what's our burn rate?"
Implementation checklist:
- Use a persistent server or cloud environment that runs 24/7
- Set up authentication for all connected services (calendar, CRM, analytics)
- Configure error handling and logging so failures get flagged
- Add monitoring so you know when automations stop running
- Build a dashboard showing what's running and when
For cron tasks, use standard cron syntax. For webhooks, use platforms like Zapier or build custom endpoints. For message triggers, use a chat interface that routes requests to the right automation.
## 3-person Team Structure
Split responsibilities: founder handles strategy, AI handles operations, humans handle relationships.
Founder (40 hours/week):
- Product strategy and roadmap
- Investor and board relationships
- Strategic customer calls
- Hiring and culture
- Financial planning
Engineer/Builder (40 hours/week):
- Core product development
- Infrastructure and DevOps
- AI automation setup and maintenance
- Customer success escalations
Growth/Ops (40 hours/week):
- Sales and customer acquisition
- Customer onboarding and success
- Content and positioning
- Partnership development
AI Operations Layer:
- Meeting scheduling (10-15 hours/week saved)
- Standup summaries (2.5 hours/week)
- Investor updates (2-3 hours/month)
- Hiring pipeline tracking (5-8 hours/week)
- Support routing (8-12 hours/week)
- Expense processing (3-5 hours/week)
Total time reclaimed: 30-40 hours per week. That's equivalent to hiring a full-time operations coordinator, but with instant response times and zero management overhead.
The key is treating AI as infrastructure, not a tool. It runs continuously in the background handling the repetitive layer while humans focus on high-judgment work.
Related reading: How to Automate Competitive Intelligence and How to Automate Your Bookkeeping and Financial Reporting with AI cover specific automation workflows.
## How Duet handles persistent startup operations
Most AI tools require you to manually trigger tasks.
For startup operations, you need automations that run 24/7 without human input.
Duet is built for persistent operations. It runs on a cloud server that never stops, handles cron-scheduled tasks like daily standups and weekly reports, responds to webhook triggers from forms or support tickets, and maintains context across all automations.
Example setup:
Create an operations session and a workspace reports folder where automated tasks keep their output. Schedule a daily standup job that runs at 9 AM, pulling from Linear, GitHub, and your CRM. Set up a webhook listener that triggers candidate research when someone submits the hiring form. Keep each automation's inputs, event history, and reports in the durable workspace.
Everything runs in one persistent environment. No switching between tools, no manual triggering, no context loss between tasks. The operations layer becomes infrastructure that's always running.
You spend 2-3 hours setting up each automation, then it runs indefinitely. A 3-person team can operate with the coordination capacity of a 6-7 person team.
Learn more at duet.so.
## What metrics show AI operations are working?
Track time saved, task completion rates, and error reduction.
Weekly operations dashboard:
| Metric | Target | Actual |
| --------------------------- | --------- | --------- |
| Meetings scheduled by AI | 8-12 | 11 |
| Time saved on scheduling | 2-3 hours | 2.5 hours |
| Standup summaries posted | 5/5 days | 5/5 |
| Hiring pipeline updates | 1/week | 1/week |
| Support tickets auto-routed | 80%+ | 85% |
| Investor update draft time | < 30 min | 25 min |
Track errors separately. If AI schedules a meeting at the wrong time or misroutes a support ticket, log it and adjust the automation rules.
Aim for 90%+ accuracy on routine tasks. The remaining 10% should fail gracefully with human review. For a 3-person team, good automation means each person gains 10-15 hours per week for strategic work.
## FAQ
### How much does it cost to automate startup operations with AI?
Expect $200-500/month for a 3-person team. This includes API costs for language models ($100-200), calendar and CRM integrations ($50-100), and hosting for persistent automations ($50-200). Compare this to hiring an operations coordinator at $60-80K annually. The payback period is immediate.
### What happens when AI makes a mistake in operations?
Build review workflows for high-stakes tasks. Investor updates should generate drafts that founders review before sending. Meeting scheduling can run fully automated since mistakes are easily corrected. Support routing should default to human review for complex issues. Start with AI drafts and human approval, then move to full automation as accuracy improves.
### How long does it take to set up AI operations?
Budget 1-2 weeks for initial setup with a 3-person team. Day 1-2: map current operations and identify automation targets. Day 3-5: set up calendar, CRM, and analytics integrations. Day 6-8: build and test first 3-4 automations. Day 9-10: train team and establish review workflows. After initial setup, add new automations incrementally as you identify bottlenecks.
### Can AI handle customer-facing operations?
Yes, but with guardrails. AI can draft customer emails, route support tickets, and generate onboarding materials. It should not send customer communications without human review during the first 3-6 months. After you've validated accuracy, gradually increase automation for routine customer interactions like scheduling, FAQ responses, and status updates. Keep relationship-building calls and complex support human-driven.
### What tasks should never be automated?
Investor relationships, strategic decisions, culture conversations, and sensitive customer situations require human judgment. Don't automate fundraising emails, performance reviews, conflict resolution, or anything involving trust and nuance. AI handles the operational layer. Humans handle strategy and relationships. Mixing these creates risk.
### How do you maintain AI automations as the company grows?
Treat automations like code. Version control your prompt templates and workflow configurations. Document what each automation does and when it runs. Assign one team member as automation owner who reviews monthly metrics and adjusts rules. As headcount grows past 10 people, dedicate an operations person to maintain and expand automations. The initial setup scales to 15-20 people before needing major changes.
### What's the biggest mistake teams make with AI operations?
Over-automating too quickly. Start with 2-3 high-value automations, validate accuracy for 2-4 weeks, then expand. Teams that automate 15 tasks simultaneously end up with broken workflows, poor accuracy, and lost trust. Build incrementally. Each automation should save 2+ hours per week and run at 90%+ accuracy before adding the next one.
---
Source: https://duet.so/blog/how-to-use-ai-to-write-sales-emails-that-get-replies
# Write Sales Emails with AI That Actually Get Replies
*Most AI sales emails get ignored. Here's the exact framework to write AI-powered emails that get real replies from real people.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 14 min read.
## How do you use AI to write sales emails?
You use AI to write sales emails by prompting large language models with your value proposition, target audience pain points, and specific call-to-action constraints. By feeding the AI customer research and past successful templates, you can generate hyper-personalized outreach sequences that significantly increase open and reply rates.
## Why Do 95% of Cold Emails Get Ignored?
The average cold email gets a 1-5% reply rate.
Most of those replies are not interested.
The problem is not that cold email is dead, it is that 95% of cold emails lead with what the sender wants instead of what the prospect actually cares about.
AI can make this dramatically better, but only if you use it right.
Dumping your pitch into ChatGPT and sending the output is how you end up in the spam folder. Using AI to research prospects at scale, personalise openers, and iterate on sequences, that is how you get reply rates that actually move the needle.
This guide covers the exact approach, the tools, and the frameworks that work in 2026.
**Quick Summary
\*\*This guide covers how to use AI to write sales emails that get replies — with frameworks and templates for subject lines, opening lines, body copy, CTAs, and follow-up sequences across cold outreach and warm campaigns.
**Questions this page answers**
Structure matters, but it's the tone calibration that separates emails that get read from ones that get deleted.
## Why Do Cold Emails Fail?
Cold emails fail because they're generic. Most outreach follows the same pattern: wrong contact, no research, templated pitch.
### The three fatal mistakes
- **No company research: **Email could apply to any business
- **Wrong recipient: **Sent to info@ or a junior employee
- **Zero personalization:**"I noticed your company" with nothing specific
Generic cold emails get 1-2% reply rates. Personalized emails referencing real company details get 12-15%. The difference is research.
Most sales teams skip research because it takes 20-30 minutes per prospect. AI can do the same work in 2 minutes.
## How Does AI-Powered Email Outreach Work?
AI outreach combines three steps: company research, contact enrichment, and personalized writing.
**The complete workflow:**
Instead of sending 20 generic emails per day, you send 50 personalized emails that reference real company details.
**Related Reading:** [How to Set Up AI-Powered Sales Prospecting for Your Startup](/blog/how-to-set-up-ai-sales-prospecting-startups)
## What Information Should You Research Before Writing?
| Email | Day | Focus |
| ------- | ------ | ------------------------------------ |
| Email 1 | Day 0 | Initial outreach — value proposition |
| Email 2 | Day 3 | Different angle / add context |
| Email 3 | Day 7 | Short bump — still relevant? |
| Email 4 | Day 14 | Break-up email — closing the loop |
Following the below-mentioned structure will help form a basic structure:
| Element | What It Does | Example |
| ------------ | ---------------------- | --------------------------------- |
| Subject line | Gets the open | Saw your post on LinkedIn... |
| Opening line | Shows you did research | You shipped X last quarter... |
| Problem hook | Identifies pain | Most [ICP] struggle with... |
| Value proof | Shows outcome | We helped [similar co] achieve... |
| Single CTA | One clear ask | Worth a 15-minute call? |
Email must include:
| Variable | Weak Version | Strong Version |
| ------------ | ------------------------- | -------------------------------------- |
| Subject line | Following up | Saw you're hiring SDRs... |
| Opening | I work at [company]... | Your [specific thing] caught my eye... |
| CTA | Let me know if interested | 15 minutes this week? |
| Tone | Formal & long | Conversational & brief |
Good outreach starts with company intelligence. The more specific details you have, the more personalized your email.
**Essential research points:**
Use Crustdata, Clearbit, or BuiltWith for company data. Apollo, ZoomInfo, or FullEnrich for contact details.
AI can aggregate this data automatically. Instead of opening 8 browser tabs, you run one enrichment workflow.
## How Do You Find the Right Contact at a Target Company?
Sending to the wrong person kills your email before it's read. You need verified contact info for actual decision-makers.
**Contact enrichment workflow:**
1. **Identify the role** - Who owns this problem? (Head of Sales, VP Engineering, etc.)
1. **Find the person** - Use LinkedIn, Apollo, or company org charts
1. **Verify the email** - NeverBounce, Hunter, or FullEnrich validation
1. **Check recency** - Is this person still in the role?
**Best contact data sources:**
- **Apollo.io** - 275M contacts, job title filters, email verification
- **FullEnrich** - Waterfall enrichment across 15+ providers
- **Hunter.io** - Email finder and verification
- **LinkedIn Sales Navigator** - Job title search, company filters
AI can run this search automatically. Give it a company name and target role, it returns verified email addresses.
Verified emails have 60-70% deliverability. Unverified emails drop to 30-40%.
## What Makes a Cold Email Feel Personalized (Not Generic)?
Personalization means referencing specific, recent, true details about the company. Not just using their name.
**Bad personalization (generic):**
> "I noticed your company is growing and wanted to reach out..."
**Good personalization (specific):**
> "Saw you just raised a Series A and are hiring 3 SDRs. Teams scaling that fast usually hit CRM chaos around 20 reps..."
The second version references real, recent details. It shows research.
**What to include:**
- **Recent event** - Funding, launch, hire, press mention
- **Specific pain point** - Based on their tech stack, size, or job postings
- **Relevant social proof** - Companies in their category you've helped
- **Clear value prop** - What you fix, not what you sell
Tables and bullets make emails easier to scan:
**Related Reading:** [How to Write High-Converting Ad Copy with AI](/blog/how-to-write-high-converting-ad-copy-with-ai)
## How Do You Write Personalized Emails at Scale?
Writing 50 personalized emails per day by hand is impossible. AI lets you keep quality while increasing volume.
**Step-by-step AI email writing workflow:**
1. **Pull enrichment data** - Company details, contact info, recent news
1. **Identify pain points** - Match their situation to problems you solve
1. **Draft email** - AI writes using enrichment data as context
1. **Human review** - Read, edit, approve (30 seconds per email)
1. **Send** - Queue in your email tool or send directly
**Example prompt for AI:**
```text
Write a cold email to [Name], [Title] at [Company].
Recent context:
- Just raised Series A ($10M, announced Jan 15)
- Hiring 3 SDRs according to LinkedIn job posts
- Using HubSpot and Outreach (from tech stack data)
- Team size: 22 employees
Our value prop: We help fast-growing sales teams clean CRM data automatically so reps spend less time on data entry.
Email should:
- Reference the Series A and SDR hiring
- Mention the pain point (CRM chaos during rapid scaling)
- Keep it under 100 words
- End with a specific question, not a calendar link
```
AI uses real details to write something that sounds human and specific.
## What Tools Do You Need for AI Email Outreach?
You need three categories: enrichment, contact data, and AI writing.
**Complete tool stack:**
You can also chain these together in one AI workflow. Instead of logging into 5 tools, you run one enrichment + writing script.
**Related Reading:** [How to Use AI as Your Personal Research Assistant](/blog/how-to-use-ai-as-personal-research-assistant)
## How Do You Run This Workflow Automatically?
Manual research and writing is slow. Automated workflows let you queue up 50 personalized emails overnight.
**Automation approach:**
1. **Input list** - Upload CSV of target companies
1. **Enrichment** - AI pulls company data, finds contacts, verifies emails
1. **Email generation** - AI drafts personalized email for each contact
1. **Human review** - You approve or edit in bulk
1. **Scheduled send** - Emails go out over 2-3 days (not all at once)
You can build this with Make.com, Zapier, or n8n. Or use an AI agent that has access to enrichment and email tools.
[Duet](/) runs this exact workflow on a persistent server. You give it a list of companies, and it handles research (pulling recent news, tech stack, company size), lead enrichment (finding decision-makers and verified emails), and email writing (drafting personalized messages that reference specific details). Because it runs on a server instead of your laptop, you can queue 50 companies overnight and wake up to drafted emails. It connects to enrichment APIs, email verification tools, and your sending platform in one workflow.
**Workflow benefits:**
- **Speed** - 50 emails researched and drafted in 2 hours
- **Consistency** - Every email follows your proven template
- **Scalability** - Run 200 companies per week without hiring
- **Quality** - AI references real details, not generic templates
**Related Reading:** [How to Set Up a 24/7 AI Agent](/blog/how-to-set-up-a-24-7-ai-agent)
## What Should Your Email Structure Look Like?
Good cold emails are short, specific, and end with a question (not a calendar link).
**Proven structure:**
1. **Specific hook** (1 sentence) - Recent news or pain indicator
1. **Why you're reaching out** (1 sentence) - The problem you solve
1. **Social proof** (1 sentence) - Relevant customer example
1. **Question** (1 sentence) - Ask if this is a priority, don't push a meeting
**Example email:**
> Subject: Your Series A + SDR hiring
> Hi [Name],
>
> Saw you raised $10M last week and are hiring 3 SDRs. Teams scaling that fast usually hit CRM data chaos around 20 reps.
>
> We help companies like [similar customer] automate CRM cleanup so reps spend less time on data entry. Saved them 8 hours/week per rep.
>
> Is clean CRM data a priority as you scale the team?
Total: 68 words. References 3 specific details (Series A, SDR hiring, team size). Ends with a question.
**What to avoid:**
- ❌ Long paragraphs (nobody reads past 3 lines)
- ❌ Calendar links in first email (too aggressive)
- ❌ Multiple CTAs (confusing)
- ❌ Feature lists (they don't care yet)
Keep it under 100 words. One clear question.
## How Do You Measure What's Working?
Track metrics at every step. Find where prospects drop off, then fix that step.
**Key metrics to track:**
Most teams focus only on reply rate. But if your deliverability is 70%, you're losing emails before they're even seen.
**What to test:**
- **Subject lines** - Question vs statement vs personalization
- **Email length** - 50 vs 100 vs 150 words
- **CTA type** - Question vs meeting link vs resource offer
- **Send time** - Tuesday 10am vs Thursday 2pm
- **Follow-up sequence** - 2 vs 3 vs 4 touches
Run A/B tests with 100 emails per variation. Winning version becomes your new baseline.
**Related Reading:** [How to Automate Competitive Intelligence](/blog/how-to-automate-competitive-intelligence-startup)
## What Follow-Up Sequence Should You Use?
Most replies come from follow-ups, not the first email. But most reps stop after one attempt.
**Recommended sequence:**
1. **Day 0** - Initial personalized email
1. **Day 3** - Bump (add value, don't just "checking in")
1. **Day 7** - Different angle (new pain point or case study)
1. **Day 14** - Breakup email ("Should I close your file?")
Each email should stand alone. Don't reference previous emails they didn't read.
**Example follow-up (Day 3):**
> Subject: Re: Your Series A + SDR hiring
> [Name],
>
> One more thing - saw you're using HubSpot. Teams at your stage often struggle with duplicate contacts when they add 3+ reps.
>
> We auto-merge dupes and standardize fields. Happy to show you how it works if CRM cleanup is on your radar.
New information. Different pain point. Still short.
**Breakup email example (Day 14):**
> Subject: Closing your file
> [Name],
>
> Haven't heard back, so I'm assuming CRM data quality isn't a priority right now.
>
> Should I close your file, or is this something to revisit in Q2?
Breakup emails get 10-15% reply rates. People respond when you're about to stop trying.
## How Do You Avoid the Spam Folder?
All your personalization is worthless if emails land in spam. Deliverability is technical.
**Spam avoidance checklist:**
- ✅ Warm up new sending domains (10 emails/day for 2 weeks)
- ✅ Use SPF, DKIM, DMARC authentication
- ✅ Keep email volume under 50/day per domain
- ✅ Avoid spam trigger words (free, guarantee, limited time)
- ✅ Don't use URL shorteners or tracking pixels
- ✅ Send from real domain (not Gmail or Yahoo)
- ✅ Personalize every email (no mass blasts)
**Spam trigger words to avoid:**
- ⚠️ Free, guarantee, limited time, act now
- ⚠️ Click here, buy now, order now
- ⚠️ Money back, risk-free, no obligation
- ⚠️ Congratulations, you've been selected
Use [Mail-Tester.com](https://www.mail-tester.com) to check spam score before sending. Aim for 8/10 or higher.
**Related Reading:** [How to Use AI to Find High-Intent Prospects for Your Freelance Business](/blog/how-to-use-ai-to-find-prospects-for-freelance-business)
## What Are Common Mistakes People Make?
Most AI outreach fails because of lazy research or over-automation.
**Mistakes to avoid:**
1. **Generic enrichment** - Using only company name and industry (not enough)
1. **No human review** - Sending AI drafts without reading them
1. **Wrong contact data** - Emailing outdated or unverified addresses
1. **Too much automation** - Removing all human touch
1. **Ignoring deliverability** - Focusing on volume over inbox placement
AI should speed up research and drafting. Humans should review, approve, and add final touches.
**What good looks like:**
- AI researches 50 companies in 1 hour
- AI drafts 50 personalized emails
- Human reviews and edits (5 seconds per email)
- Emails send over 3 days (not all at once)
- Deliverability stays above 95%
Speed without quality is spam. Quality without speed doesn't scale.
## Frequently Asked Questions
### How long should a cold email be?
60-100 words is optimal. Shorter emails (under 50 words) feel abrupt. Longer emails (over 150 words) don't get read. Your email should fit on a phone screen without scrolling. Use 3-4 short sentences and one clear question at the end.
### What's a good reply rate for AI-written emails?
Personalized AI emails should get 12-15% reply rates and 4-6% positive replies (actual interest, not just "unsubscribe"). Generic templates get 1-2% replies. If you're below 10%, your research or personalization is too weak. Check if you're referencing specific, recent, true details about each company.
### Should you use AI to send emails automatically?
No. AI should research and draft. Humans should review and approve. Sending without human review leads to mistakes - wrong details, awkward phrasing, or irrelevant pitches. Review takes 5 seconds per email. It's worth it to catch errors before they damage your reputation.
### How many follow-ups should you send?
Send 3 follow-ups over 14 days (Day 3, Day 7, Day 14). Most replies come from follow-up #2 or #3. After 4 total touches with no response, stop. Sending more than 4 emails without replies is spam. If they're interested, they'll reply within 2 weeks.
### What subject lines get the highest open rates?
Specific subject lines referencing recent company news get 50-60% open rates. Examples: "Your Series A announcement" or "Hiring 3 SDRs?" Generic subjects get 20-30% opens. Avoid clickbait ("Quick question" or "Saw your LinkedIn"). Be specific and relevant.
### Can AI outreach work for enterprise sales?
Yes, but you need deeper research. Enterprise buyers expect more sophistication. Pull details about tech stack, org structure, recent initiatives, and relevant case studies. Reference their specific business challenges, not generic pain points. Enterprise emails should be 100-150 words with clear social proof.
### How do you prevent AI emails from sounding robotic?
Use conversational prompts. Tell AI to write like a human colleague, not a marketing team. Avoid corporate jargon, exclamation points, and buzzwords. Read every email out loud before sending. If it sounds like a robot wrote it, rewrite. Good AI emails sound like you researched the company and wrote a quick, helpful note.
---
---
Source: https://duet.so/blog/how-to-write-high-converting-ad-copy-with-ai
# Write High-Converting Ad Copy with AI
*Ad copy that actually converts starts with the right AI prompts. Here's the framework we use to write ads that hit.*
By Duet Team. Published 2026-03-01, updated 2026-05-08. 14 min read.
# How to Write High-Converting Ad Copy with AI (That Doesn't Sound Like AI)
Most ad copy fails for a simple reason.
It's written from the advertiser's perspective, not the customer's. Features, awards, years in business, none of that is what makes someone click.
What makes someone click is seeing their exact problem reflected back at them with a clear promise of relief.
AI can help you write better ad copy, a lot better, but only if you give it the right inputs.
This guide covers the frameworks that actually drive conversions, how to use AI to generate and iterate on copy at scale, what works differently across Google, Meta, and Reddit, and how to diagnose copy that isn't converting. Concrete, not theoretical.
Quick Summary
This guide covers how to use AI to write high-converting ad copy for Google Ads, Meta, LinkedIn, and Reddit. With frameworks, prompts, and real examples for headlines, body copy, and CTAs that drive clicks.
Questions this page answers
- How to write ad copy with AI
- Best AI tools for ad copywriting
- How to use AI to improve ad performance
- AI ad copy frameworks that convert
- Can AI write better ad headlines than humans?
The best AI ad copy doesn't reveal itself as AI-generated.
Feed your AI tool competitor data, brand voice samples, and audience insights before writing.
Use it to generate 20+ variations per campaign, then A/B test systematically.
Most marketers skip the research phase and get generic results; competitive intelligence and voice training are what separate 2% click-through rates from 8%.
## Why Most AI-Generated Ad Copy Fails
Generic AI ad copy gets ignored because it lacks differentiation. When you prompt an AI ad copy generator with "write a Facebook ad for accounting software," you get the same vanilla output as every competitor using the same approach.
Three failure points kill AI-generated ads:
- No brand voice: The copy sounds like a corporate press release, not your actual brand personality
- Zero competitive context: AI doesn't know what messaging angles your competitors already own
- Missing audience data: Without customer language and pain points, AI invents problems no one actually has
Most marketers treat AI like a vending machine: insert generic prompt, receive mediocre copy. High-performing campaigns require front-loading research before any writing happens.
## How Do You Train AI on Your Brand Voice?
Start by feeding AI 5-10 examples of your best-performing copy. Include emails, landing pages, and previous ads that drove conversions.
Create a brand voice document with:
- Tone descriptors: Conversational, technical, irreverent (pick 3-4 specific adjectives)
- Forbidden phrases: Corporate jargon you never use ("synergy," "leverage," "best-in-class")
- Sentence structure rules: Average sentence length, question usage frequency, punctuation style
- Vocabulary preferences: Industry terms you embrace vs. avoid
Example prompt structure:
```plaintext
Brand voice: Direct, slightly irreverent, uses short sentences.
We say: "Cut your reporting time in half"
We don't say: "Optimize operational efficiency"
Now write 10 Google Ads headlines for [product].
```
This approach works for ai tools for marketing agencies managing multiple client brands. Save each client's voice profile and reuse it across campaigns.
## What Research Should You Do Before Writing?
Competitive ad research tells you which messaging territories are crowded and which are open. Spend 30 minutes gathering intel before writing a single word.
Step 1: Scrape competitor ads
Use Facebook Ad Library, Google Ads Transparency Center, or third-party tools to collect 20-30 competitor ads. Look for patterns in:
- Headline formulas (question-based, stat-driven, pain-focused)
- Value propositions (price, speed, features, outcomes)
- Call-to-action styles (urgency-based, risk-reversal, curiosity-driven)
Step 2: Analyze customer language
Mine reviews, support tickets, and sales call transcripts for exact phrases customers use to describe problems and desired outcomes. AI-generated copy converts better when it mirrors customer vocabulary, not marketing speak.
Step 3: Document proven patterns
Build a swipe file of high-performing ads in your category. Note specific elements: headline structure, body copy length, image style, offer format.
## How Do You Generate High-Converting Variations?
Volume beats perfectionism in ad copy testing. Generate 20+ variations per campaign, then let data decide winners.
Prompt framework for batch generation:
```plaintext
Context:
- Product: [name and category]
- Audience: [demographics and psychographics]
- Competitor angles: [3-5 messaging territories they own]
- Brand voice: [your guidelines]
Generate 20 Google Ads headlines that:
- Avoid competitor messaging angles
- Use customer language from: [paste 5-10 customer quotes]
- Match brand voice guidelines
- Focus on [specific benefit or outcome]
Format: One headline per line, 30 characters max.
```
This structured prompt gives AI constraints that force creative differentiation. Generic prompts produce generic copy.
Testing framework:
Always keep testing. The ad that works today saturates in 2-3 weeks.
## What Are Platform-Specific Best Practices?
Each ad platform has different character limits, audience behaviors, and creative requirements. AI-generated copy needs platform-specific formatting.
### Google Ads
Character limits:
- Headlines: 30 characters (3 headlines per ad)
- Descriptions: 90 characters (2 descriptions per ad)
Best practices:
- Put primary keyword in Headline 1
- Use numbers and symbols (%, $, #) to stand out
- Description 1 = benefit, Description 2 = CTA
- Create 3-5 ad variations per ad group
Example prompt:
```plaintext
Write 10 Google Ads combinations for [product].
Format each as:
H1 (30 char): [keyword-focused]
H2 (30 char): [benefit-focused]
H3 (30 char): [differentiation]
D1 (90 char): [expand on benefit]
D2 (90 char): [CTA with urgency]
```
### Meta (Facebook/Instagram)
Creative flexibility is higher, but attention span is lower. First 125 characters determine if users click "see more."
Winning patterns:
- Pattern interrupt: Open with unexpected statement or question
- Scroll-stopper: First line must justify why they should stop scrolling
- Social proof: Mention customer count, ratings, or testimonials in first two sentences
- Mobile-first: 90% of users are on mobile; write for thumb-scrolling
Character limits:
- Primary text: 125 characters display initially (no hard limit)
- Headline: 27 characters on mobile
- Description: 27 characters
### LinkedIn Ads
Professional context demands different copy. Decision-makers are in work mode, judging credibility and ROI.
Effective approaches:
- Lead with business outcome metrics ("Cut reporting time 60%")
- Use job titles and company size in targeting language
- Avoid hype; focus on process and proof
- Longer copy performs better than Meta (up to 150 characters)
LinkedIn users respond to case studies, whitepapers, and webinar offers more than direct product pitches.
### TikTok Ads
Native TikTok ads must look like organic content or they get scrolled past instantly. The platform punishes obvious advertising.
Copy principles:
- Write for 9:16 vertical video, not static images
- First 3 seconds = hook (question, surprising stat, pain point)
- Keep total length under 21-34 seconds
- Use captions (80% watch without sound)
- CTA should feel conversational, not salesy
AI struggles with TikTok native tone. Use it for ideation and script outlines, then manually adapt to platform voice.
## How Do You Build a Reusable Prompt Library?
Marketing agencies running 10+ client campaigns need systematized prompt templates. Building a library saves 70% of copywriting time.
Prompt library structure:
Create separate templates for:
1. New product launches (benefit-focused, feature education)
1. Seasonal promotions (urgency, scarcity, timely hooks)
1. Retargeting campaigns (objection handling, social proof)
1. Competitor displacement (comparison, switching incentives)
1. Lead generation (curiosity, value exchange for contact info)
Each template includes:
- Placeholder fields for client specifics
- Brand voice injection point
- Competitor context section
- Output format requirements
Example reusable template:
```plaintext
[SEASONAL PROMOTION TEMPLATE]
Product: [NAME]
Offer: [DISCOUNT/BONUS/TERMS]
Audience: [DEMOGRAPHICS]
Competitor angles to avoid: [LIST]
Brand voice: [GUIDELINES]
Urgency mechanism: [DEADLINE/SCARCITY/FOMO]
Generate 15 [PLATFORM] ads that:
- Lead with the offer in first 5 words
- Create urgency without being pushy
- Match [BRAND] voice
- Stay within [PLATFORM] character limits
Format: [SPECIFY]
```
Save each template as a document. When a new campaign starts, fill in brackets and generate in 5 minutes instead of 45.
## How Can AI Remember What Worked Across Sessions?
The biggest advantage in AI ad copywriting isn't generation speed. It's memory across campaigns.
Traditional workflows lose institutional knowledge. A campaign runs, you see what worked, then three months later you're starting from scratch because no one documented the insights.
AI that maintains memory across sessions compounds learning. When you run a Meta campaign and Headline Formula B outperforms Formula A by 40%, that insight informs every future campaign automatically.
This works when your AI workspace:
- Stores past campaign performance data (CTR, CPA, conversion rate by ad variation)
- Remembers which customer language drove response vs. flopped
- Tracks which competitor angles you've already tested and which are untapped
- Maintains your evolving brand voice guidelines as they shift over time
For agencies, this becomes powerful at scale. Each client's workspace accumulates 6-12 months of "what worked" data. New campaign briefs automatically reference past winners. Junior team members access senior-level strategic thinking baked into prompts.
The workflow looks like:
1. Pull competitor ads and analyze messaging patterns (research phase)
1. Feed research + brand voice + past performance data into generation
1. AI outputs 20 variations informed by what actually converted before
1. Run tests, feed results back into the system
1. Next campaign starts smarter
Tools that combine research, writing, and memory in one workspace eliminate the "start from zero" problem. That's where Duet is positioned for marketing teams running high-volume ad creation.
## What Metrics Actually Matter for Ad Copy Performance?
Vanity metrics mislead. Focus on four numbers that connect copy quality to revenue.
Click-through rate (CTR):
- Industry average: 2-3% for search, 0.9% for display, 1-2% for social
- Good performance: 2x industry average
- Great performance: 3x+ industry average
CTR tells you if your hook works. Low CTR means your copy isn't relevant or differentiated enough.
Cost per acquisition (CPA):
- Varies wildly by industry (B2B SaaS: $200-400, e-commerce: $20-50, local services: $50-150)
- Track against your target CPA from unit economics
- CPA = total ad spend / conversions
If CTR is high but CPA is terrible, your copy attracts the wrong audience or sets wrong expectations.
Conversion rate (CVR):
- Landing page conversion: 2-5% average, 10%+ is excellent
- Ad-to-landing page message match is critical
- If ad promises X but landing page delivers Y, CVR tanks
AI-generated ad copy must align with landing page content. Misalignment kills campaigns that look promising in early CTR data.
Return on ad spend (ROAS):
- Minimum viable: 2:1 (every $1 spent returns $2 revenue)
- Healthy: 3-4:1
- Exceptional: 5:1+
ROAS is the ultimate judge. Great copy attracts qualified buyers at profitable rates.
## How To Scale Ad Copy Production Without Quality Loss?
Volume and quality aren't enemies when you systematize the process. Agencies producing 100+ ad variations weekly need assembly-line efficiency.
Batch production workflow:
Monday: Research sprint
- Pull competitor ads across all active clients
- Analyze new customer language from past week's sales calls
- Update voice guidelines based on any brand shifts
Tuesday-Wednesday: Generation sprints
- Run templatized prompts for all campaigns launching that week
- Generate 20 variations per campaign
- Junior team reviews for obvious errors (wrong product names, broken logic)
Thursday: Quality control
- Senior copywriter spot-checks 20% of output
- Flag patterns that need prompt refinement
- Approve batch for client review
Friday: Launch prep
- Clients review and approve (or request tweaks)
- Upload to ad platforms
- Set up tracking parameters
This workflow lets a 3-person team produce what used to require 8 copywriters. Quality stays high because research and voice training happen systematically, not ad-hoc.
## Common Mistakes That Tank AI Ad Copy?
Even with good prompts, specific mistakes cause underperformance. Watch for these patterns.
Mistake 1: Overloading with features
AI loves listing features. Customers care about outcomes. Always prompt for benefit-driven copy.
Bad: "Our CRM includes contact management, email automation, and pipeline tracking."
Good: "Close 30% more deals by never losing track of a lead."
Mistake 2: Ignoring character limits mid-sentence
AI often generates 35-character headlines for 30-character limits. It doesn't auto-truncate gracefully. Always specify exact limits and verify before uploading.
Mistake 3: Using the same variation across platforms
LinkedIn copy bombs on TikTok. Instagram copy feels stiff on Google. Generate platform-specific variations, not copy-paste across channels.
Mistake 4: No negative prompting
Tell AI what NOT to include: "Avoid using words like 'revolutionary,' 'game-changing,' or 'unlike anything else.'"
Mistake 5: Skipping human review on claims
AI occasionally invents statistics or capabilities. Always verify any numbers, guarantees, or specific claims before running ads. False advertising is expensive.
## Frequently Asked Questions
### Can AI really write ad copy that converts better than human copywriters?
AI doesn't replace good copywriters; it multiplies their output. Top-performing campaigns use AI for volume generation (20+ variations) and human judgment for strategic direction and final selection. A skilled copywriter using AI will outperform one working manually by 5-10x on volume while maintaining quality. The best results come from AI handling first drafts and pattern variations while humans provide brand voice training, competitive strategy, and quality control.
### How do I prevent AI-generated ads from all sounding the same?
Feed unique inputs: your specific brand voice docs, competitor research for your niche, and actual customer language from your reviews and support tickets. The sameness problem comes from generic prompts. Two advertisers using identical prompts will get identical output. Differentiation happens in the research and context you provide before generation. Also use negative prompting to explicitly forbid overused phrases and patterns you've seen competitors use.
### What's the best AI ad copy generator for marketing agencies?
The best tool depends on workflow needs. Agencies managing multiple clients need tools that maintain separate brand voice profiles and remember past campaign performance per client. Look for AI that integrates research (competitor ad scraping, customer language analysis) with writing in one workspace, rather than copying data between tools. The ability to save and reuse prompt templates across clients saves significant time at scale.
### How much should I budget for A/B testing AI-generated ad variations?
Start with $500-1000 per campaign to test 15-20 variations across 5-7 days. This gives statistical significance for CTR comparison. Allocate budget equally across variations initially, then shift spend to top performers. For established campaigns, use a 70/15/15 split: 70% to proven winner, 30% split between new challengers. Never stop testing; winning ads saturate after 2-4 weeks and need replacement.
### Do I need different prompts for Google Ads vs. Facebook vs. LinkedIn?
Yes. Each platform has different character limits, audience mindsets, and creative formats. Your prompt should specify platform constraints: Google Ads headlines max at 30 characters, Meta primary text should hook in first 125 characters, LinkedIn copy skews longer and more professional. Create separate prompt templates per platform, but maintain consistent brand voice across all. The strategic message stays the same; the formatting and tone shift per platform.
### How do I measure if AI ad copy is actually saving time and money?
Track three metrics: time-to-launch (how many hours from brief to live campaign), cost-per-variation (total cost divided by number of unique ads tested), and performance delta (CTR and CPA improvement vs. your manual baseline). A typical agency sees 60-70% time reduction and 3-5x increase in variations tested per campaign. The real ROI shows up in performance: more variations means higher probability of finding a winner that significantly beats your control.
### Can I use AI to write ad copy in languages other than English?
Modern AI handles 50+ languages, but quality varies. Major languages (Spanish, French, German, Mandarin) perform well. For best results, provide brand voice examples and customer language samples in the target language rather than translating from English. Cultural context matters; idioms and humor don't translate directly. If running global campaigns, work with native speakers to review AI output for cultural fit and natural phrasing, especially for languages with formal/informal distinctions.
---
Source: https://duet.so/blog/how-we-benchmark-ai-models-on-real-work
# How to Benchmark AI Models on Real Work (Not Leaderboards)
*Leaderboards test models on invented prompts. Here's how to benchmark AI models on real work — completion, switch-away, tool reliability, and blind quality.*
By Duet Team. Published 2026-07-02, updated 2026-07-02. 11 min read.
Benchmarking an AI model on real work means measuring how models perform on tasks people actually needed done, not on invented test prompts or crowd votes. Rather than scoring models against a fixed exam, it observes real-world signals — whether the task got completed, whether the user switched models, and how reliably the model used its tools.
Public leaderboards answer "which model scores highest on a fixed test?" Operators ask "which model will get _my_ work done?" For the buyer's-guide version, see [how to choose the right AI model for your business](/blog/how-to-choose-the-right-ai-model-for-your-business); this is the method underneath it.
## What is an AI benchmark, and how do leaderboards actually work?
An AI benchmark is a standardized exam given to every model — same questions, same grading — so scores line up side by side. IBM breaks it into three steps: setting up the dataset, testing every model on identical inputs, and scoring the results onto a leaderboard.
Two dominant public methods exist. Standardized suites run models through a fixed battery of graded tests; [Artificial Analysis's benchmarking methodology](https://artificialanalysis.ai/methodology) is the rigorous example, with formal metrics and explicit formulas. Crowd-vote arenas work differently: two anonymous models answer a prompt, the user votes, and votes aggregate into a chess-style Elo rating — that's how [the LMArena leaderboard](https://lmarena.ai/) ranks models.
Both are legitimate designs — but each only tests [what an LLM benchmark actually is](https://www.ibm.com/think/topics/llm-benchmarks) built to measure: performance on set questions, under set conditions, on test day.
## Are AI benchmarks accurate?
They're accurate at what they measure — performance on a fixed set of questions on test day — but that does not reliably predict real-world usefulness. IBM states plainly that benchmarks "can't predict how well a model will operate in the real world" and "may not be a fitting metric for edge scenarios, specialized areas or specific use cases."
Two structural problems inflate scores. **Saturation:** when top models all cluster near the maximum, the test can no longer tell a great model from a good one — BIG-Bench saturated less than a year after release. **Contamination:** "the unintended overlap between training and test data" (arXiv:2502.14425) — the model may have trained on the answer key; one analysis of 31 models on math reasoning found widespread contamination.
Confident AI admits the limit outright: "LLMs are probabilistic machines, which makes defining deterministic test cases inadequate."
## Why don't AI leaderboards match your real-world results?
Because a leaderboard is a target, and targets get gamed. Goodhart's Law — "when a measure becomes a target, it ceases to be a good measure" — applies to every public ranking: once labs optimize for a score, the score decouples from the capability it was meant to proxy.
This has been measured, not just theorized. A 2025 study, [The Leaderboard Illusion](https://arxiv.org/abs/2504.20879) (arXiv:2504.20879), found access to arena data could yield relative performance gains of up to 112% on the arena's distribution — climbing by learning the test, not getting better. It also identified 27 private model variants tested by one provider before a major release, with only the best scores published. Its conclusion: these dynamics cause "overfitting to arena-specific dynamics rather than general model quality."
The clearest illustration was the Llama-4 episode in April 2025, when the version topping the leaderboard was not the model released to the public. For a fair account of the controversy — including the pushback from arena defenders — see [Simon Willison's breakdown of the Chatbot Arena criticism](https://simonwillison.net/2025/Apr/30/criticism-of-the-chatbot-arena/). Willison also notes crowd votes reward surface features: "bulleted lists and answers of a very specific length tend to do better."
Leaderboards aren't worthless — they measure preference on invented prompts, which is why your own experience, like [Codex vs Claude Code](/blog/codex-vs-claude-code) on your actual repo, often disagrees with the ranking.
## How is benchmarking on real work different from testing on benchmarks?
The difference is administered questions versus observed outcomes. A benchmark is given before deployment, in clean conditions, on fixed inputs. Real-work benchmarking watches what happens after deployment, on messy tasks people needed done. Benchmarks test; we observe.
Said as a single contrast: crowd-vote leaderboards measure preference on invented prompts; standardized suites measure performance on fixed tests; real-work benchmarking measures outcomes on tasks people actually needed done.
The three methods differ on what they measure, where their data comes from, and how each one breaks:
| Method | What it measures | Data source | Known failure mode |
| ---------------------------------- | ------------------------------------ | --------------------------------- | -------------------------------------------------------- |
| Crowd-vote leaderboard (Elo/arena) | Human preference on invented prompts | Anonymous pairwise votes | Gameable; rewards length/formatting; Goodhart pressure |
| Standardized suite | Performance on a fixed test set | Ground-truth graded exams | Saturation and contamination; clean-room conditions only |
| Real-work observation | Outcomes on tasks people needed done | Aggregated, anonymized real usage | Sample and task-mix skew; needs privacy guardrails |
Serious evaluation is already moving toward realism — the first of Cameron Wolfe's [design principles for a useful benchmark](https://cameronrwolfe.substack.com/p/llm-bench) is "realistic," citing CursorBench, which sources its data from real coding-agent sessions. Real work is the ultimate held-out set: it didn't exist until the user created it, so it can't be memorized.
## What signals actually tell you a model did the job?
Five signals, drawn from observed work rather than a test sheet. Each answers one question: did the model do the work?
| What we measure | What it tells you | Why synthetic benchmarks miss it |
| --------------------------------- | ----------------------------------------------------------- | ------------------------------------------------ |
| Completion | Did the job actually get finished? | Exams score answers, not finished jobs |
| Switch-away / implicit preference | Did the user quietly abandon the model mid-task? | Sandbox votes are free; real switches cost time |
| Tool reliability | Did it call tools and integrations correctly? | Static tests measure capability in isolation |
| Infra recovery / robustness | Did it recover from rate limits, timeouts, errors? | Lab suites run in clean conditions |
| Blind quality | How good is the output when the grader can't see the model? | Brand halo and self-preference bias open grading |
- **Completion** is the share of real tasks that reached a successful finish rather than stalling or being abandoned — an outcome, not a proxy.
- **Switch-away** is when a person abandons or swaps a model mid-task; it's a revealed preference under real stakes, because it cost them time.
- **Tool reliability** is how consistently a model calls its tools and integrations correctly across runs — a model can write beautiful prose and still botch every tool call.
- **Infra recovery** is whether a model handles real-world failure — rate limits, timeouts, transient errors — and still finishes.
- **Blind quality** grades outputs on a fixed, anonymized prompt set without the grader knowing which model produced them, controlling for position, length, and self-preference bias.
The switch-away signal has external backing. In April 2025 (via Simon Willison), Andrej Karpathy acknowledged overfitting pressure on the arena and proposed usage-based rankings — like OpenRouter's — as a candidate top-tier eval that is "very difficult to game," because users switching models are "directly voting for some combo of capability+cost." That's the honest vote: [routing work to the right model for the job](/guides/claude-opus-vs-sonnet-model-routing).
## Why do we separate real interactive work from scheduled automation?
Because they are different animals, and mixing them would corrupt the completion signal. An interactive session has a human at the keyboard and a clear finish. A scheduled or long-running automation may run for days, wait on an external event, or never emit a "task done" event.
Counting those runs in "did the task get done" would distort it — making models look worse or better for reasons unrelated to quality — so they're separated out. That exclusion isn't a caveat; it's proof the method knows the difference between a person working live and a scheduled job, a distinction a lab-suite vendor has no real work to make.
## Why do we distrust our own leaderboard?
Because Goodhart applies to us too. Any measure — including a real-work one — can mislead, and pretending otherwise is the confidence leaderboards project right before they get gamed. "No single evaluation metric should be trusted in isolation."
Named honestly, the risks are sample skew (some models get more usage), task-mix differences between users, and Goodhart pressure the moment any signal becomes a public target. The guardrails: session-type separation, blind grading, directional-not-absolute reporting, and no public per-model target to optimize toward yet.
Privacy is part of that integrity. Measurement is aggregate-only and anonymized — patterns across many users, no individual raw prompts read or published — a deliberate contrast with arenas whose own notices warn conversations may be published. Reporting directionally, and calling it "coming soon," is the honest version of the claim, not an incomplete one.
## How should you decide which AI model is best for you?
There is no universal best model; the right choice is task-dependent. Judge candidates on the same real-work outcomes — completion, switch-away, tool reliability, robustness, blind quality — for _your_ kind of work, not on a single leaderboard rank. The model that drafts email well may be wrong for debugging code, which is why [comparing coding models head-to-head](/blog/claude-code-vs-cursor-vs-codex) and surveying [the best AI agent builders](/blog/6-best-ai-agent-builders-in-2026) beats trusting one crown.
This is the problem Duet is unusually positioned to work on. Because Duet lets you run your work on many different models rather than selling any one of them, it sits on a neutral vantage point — it can watch real, anonymized work flow through all of them and ask the question tests can't: did the job actually get done? That's the "run" half of Duet's build-and-run approach — helping you operate on whichever model does _your_ work best, not crowning a favorite. Concretely, it judges models on the five real-work signals above, measured only in aggregate and anonymized, with no raw prompts read or published, and with scheduled automation separated from interactive sessions so it doesn't distort the picture. We're assembling these signals into a Duet Model Index, coming soon. Until then, the method is the takeaway: [judge models on the work you actually need done](/blog/how-to-choose-the-right-ai-model-for-your-business).
Benchmarks test; we observe.
## Frequently asked questions
**What does it mean to benchmark an AI model on real work?**
Benchmarking on real work means measuring how models perform on tasks people actually needed done — observing whether the task was completed, whether the user switched models, and how reliably the model used its tools — instead of scoring them on a fixed exam or crowd votes.
**Are AI benchmarks accurate?**
They're accurate at what they measure — a model's performance on a fixed set of test questions on test day — but that does not reliably predict real-world usefulness. IBM notes benchmarks "can't predict how well a model will operate in the real world," and scores can be inflated by saturation and training-data contamination.
**Why don't AI leaderboards match my experience?**
Leaderboards test models on prompts people invent to test, not on work they actually needed done, and once a score becomes a target it comes under Goodhart's Law pressure. A 2025 study, "The Leaderboard Illusion," documented private variant cherry-picking and gains of up to 112% just from learning the arena's dynamics.
**What is the difference between LLM evaluation and benchmarking?**
Benchmarking usually means running models through a fixed, standardized test suite; evaluation is the broader practice of judging whether a model is fit for a purpose, including post-production real-work signals. Benchmarks are one input to evaluation, not the whole of it.
**What is the switch-away signal?**
The switch-away signal is when a person abandons or swaps a model mid-task on real work — a revealed preference under real stakes, because it cost them time. Researcher Andrej Karpathy has argued that usage-based rankings built on this kind of real switching are "very difficult to game."
**How should I choose which AI model is best for me?**
There is no universal best model; the right choice is task-dependent. Judge candidates on outcomes for your kind of work — did the task get completed, did you stay with the model, did it call tools reliably — not on a single leaderboard rank.
**Does real-work benchmarking use my private data?**
A privacy-first approach measures aggregate, anonymized patterns across many users and never reads or publishes individual raw prompts. Long-running and scheduled automation is also separated out, because it doesn't emit the same completion signals as interactive work.
---
Source: https://duet.so/blog/how-we-grew-google-traffic-800-percent-with-ai
# How We Grew Google Traffic 800% in 6 Weeks With AI
*800% traffic growth in 6 weeks using AI-assisted content strategy. Here's exactly what we did and what you can replicate.*
By Sawyer Middeleer. Published 2026-03-13, updated 2026-05-08. 15 min read.
Six weeks. 800% more organic traffic. No backlink campaigns, no technical overhauls, no agency. Just a content strategy built on AI and executed faster than we'd ever produced content before.
This is the full breakdown of how we did it, the keyword strategy, the content structure, the AI workflow, the tools, and the things that didn't work the first time. We're sharing it because the approach is repeatable: it worked because we got the fundamentals right, not because we got lucky. If you have an existing site with some domain authority and a clear topic area, the same playbook should work for you.
**Quick Summary**
This case study covers how the Duet team grew Google organic traffic by 800% in 6 weeks using AI — with the content strategy, tools, workflows, and specific tactics that drove results and a replicable playbook.
**Questions this page answers**
- How to grow Google traffic with AI
- AI SEO strategy that drove 800% traffic growth
- How to scale blog content production with AI
- Best AI tools for SEO content creation
- What is an AI-powered SEO content workflow?
Six weeks ago, Duet was invisible on Google. We had four guides, zero blog posts, no structured data, and no third-party presence. Our Google Search Console dashboard was a flatline.
Today we're at 7,143 weekly impressions, 56 weekly clicks, a 0.78% CTR, and Google sent us a congratulatory email for hitting 80 clicks in 28 days. Our daily impressions went from 77 to 1,543, a 20x increase.
We didn't hire an SEO agency. We didn't spend $5,000/month on a retainer. We used our own AI agent to do the entire thing, keyword research, technical SEO audits, content generation, structured data implementation, and weekly performance tracking.
Here's the exact playbook.
---
## Where We Started
On February 10, 2026, we ran our first SEO audit. The results were humbling:
We had four Claude Code guides that were picking up some organic impressions, but that was it. No blog, no structured data, no third-party presence, no comparison pages. The site was functionally invisible for any non-branded query.
The "duet" brand query itself was a problem Google's former Duet AI product, Duet Display, a dating app called Duet, and a PM tool called Duet were all competing for the same keyword. We were getting 904 impressions on "duet" with a 0.2% CTR because most of those searchers weren't looking for us.
| Mistake | Impact | Fix |
| ------------------------------ | ---------------- | ------------------------------- |
| Thin content (under 800 words) | Low rankings | Target 1200+ words |
| No internal linking | Orphan pages | Link every article to 3+ others |
| Ignoring search intent | High bounce rate | Match format to query type |
| Publishing without indexing | Delayed traffic | Use GSC to request indexing |
The content volume was only part of the equation, here's what made it actually rank.
## AI Agent Instead of Agency
A typical SEO agency charges $3,000–$7,000/month. For that, you get keyword research, a content calendar, some blog posts, and a monthly report. The actual value breaks down to about $800 in tool subscriptions, $2,200 in analyst hours, and $2,000 in content production.
We had something agencies don't: a persistent AI agent running on its own cloud server with access to DataForSEO, Google Search Console, Firecrawl, and the ability to write and ship code. Our agent could run keyword research, write content, generate structured data, create PRs in our codebase, and track results — all without context-switching between five different SaaS dashboards.
So we pointed our AI agent at the problem and let it work.
## Technical SEO Foundation
Before writing a single blog post, the agent identified our biggest technical gaps and shipped fixes as pull requests.
### Structured Data (JSON-LD)
The agent added three layers of structured data:
1. Homepage: Organization + SoftwareApplication + WebSite schemas — telling Google exactly what Duet is, who built it, and how to categorize it
1. Guide pages: TechArticle + BreadcrumbList + conditional FAQPage schemas — marking up every guide with rich snippet eligibility
1. Guides listing: CollectionPage + ItemList schema — structuring the guides index for Google's crawler
This was PR #661, #663, and #715. Before these, Google had zero structured data to work with. After, every page was machine-readable.
### AI Bot Crawling Rules
We updated robots.txt with explicit allow rules for AI crawlers — GPTBot, ChatGPT-User, PerplexityBot, ClaudeBot, OAI-SearchBot, and Google-Extended. Most sites either block these or don't address them. We wanted AI models to index our content for citation in AI-generated answers.
### Title and Meta Optimization
The agent audited every guide title and meta description (PR #649, #651). Our Claude Code beginners guide had 1,928 impressions but a horrific 0.1% CTR — the title was 63 characters and getting truncated in search results. After shortening it to 49 characters and rewriting the meta description, CTR improved 233% over the following weeks.
Results after Week 2:
Five PRs shipped. The foundation was set.
## The Content Blitz
With the technical foundation in place, the agent shifted to content.
### Keyword Strategy
The agent ran comprehensive keyword research using DataForSEO across our target segments (solopreneurs, startups, agencies) and personas (GTM, product dev, operations). It identified high-opportunity keywords where search volume existed but competition was low enough for a new domain to rank.
The critical insight: our Claude Code guides were driving 90% of all organic impressions. The "Claude Code for Founders" guide had the highest CTR of any page (3.63%) because it targeted a specific business use case rather than a generic technical tutorial. The business-angle content was outperforming generic technical content by 10x on CTR.
### 30 Blog Posts in One Day
On March 1, we published 30 blog posts. The AI agent researched topics, wrote content, optimized for target keywords, and submitted PRs. Topics ranged from "How to Automate Competitive Intelligence for Your Startup" to "Build and Deploy a Web App Using Only AI" — all targeting the long-tail keywords the research had identified.
The sitemap auto-generates from the content directory, so all 30 posts were immediately discoverable by Google's crawler. No manual sitemap submission needed.
### Comparison Guides
We shipped five comparison guides (Duet vs Claude Code, Duet vs Codex, Duet vs Conductor, Duet vs OpenClaw, Duet vs Slack) targeting the "X vs Y" queries that AI models and search engines both prioritize. These got indexed within days — faster than any other content type we published.
Results after Week 4:
Google sent us a milestone email: "Congrats on reaching 80 clicks in 28 days."
## Optimization and Compounding
With the content published and indexing, the agent shifted to optimization.
### Shorter Titles, More Clicks
Here's the single most actionable thing we learned: shorter titles get more clicks, even with fewer impressions.
Our Claude Code beginners guide had a 63-character title that was getting truncated in search results. The agent shortened it to 49 characters. The result: CTR doubled — from 0.32% to 0.63%. The page actually lost 21% of its impressions, but gained 57% more clicks. Fewer people saw it, more people clicked it. That's the power of a title that fits in Google's display window.
We applied this across all 35 blog posts — enforcing a strict 60-character limit on every title. Before the fix, 22 of our 30 original posts were silently losing clicks to truncation from day one.
### Google Started Indexing Our Sections
Something we didn't expect: Google began surfacing individual sections of our pages as separate search results. Our beginners guide alone spawned 9 section-level entries in Search Console — anchors like #what-is-claude-code and #why-use-claude-code — generating over 160 additional impressions on their own.
We didn't do anything special to trigger this. No extra markup, no manual submissions. Google just decided the page was structured well enough to break into pieces and surface each one independently. It's a strong signal that well-organized long-form content with clear headings compounds in ways you can't predict — and a free multiplier on content you've already written.
### AI Visibility Monitoring
Every week, the agent ran a structured AI visibility check — querying ChatGPT, Perplexity, and other AI models with category, comparison, and problem queries to see if Duet appeared in AI-generated answers.
Our AI citation rate went from 0% to 22% over the six weeks. We appeared in both brand queries. Category queries remained at 0% — the agent identified that every category query ("best AI workspace," "slack alternatives with AI agents") returned listicles from G2 and Capterra, platforms where we had zero presence.
After four consecutive weekly reports recommending it, we finally created G2 and Capterra profiles in week 5.
### Backlink Strategy
The agent analyzed opportunities for backlinks from established sites with more domain authority than duet.so:
- Footer links — baseline link equity from a higher-authority domain
- Homepage banners introducing Duet — a prominent individual link
- Blog posts explaining why we built Duet — editorial links that pass authority
One strategic homepage link from a higher-authority domain is worth more than 100 footer links from an SEO standpoint.
## What the AI Agent Actually Did
Let me be specific about the division of labor, because "we used AI" is vague.
The AI agent autonomously:
- Ran weekly Google Search Console performance pulls and generated reports
- Identified technical SEO gaps (missing structured data, truncated titles, missing meta descriptions)
- Generated JSON-LD schemas and submitted them as pull requests
- Conducted keyword research using DataForSEO APIs
- Wrote 30+ blog posts optimized for target keywords
- Tested AI citation rates across multiple AI models weekly
- Recommended strategic actions ranked by expected impact
- Tracked week-over-week metrics and flagged anomalies
Humans decided:
- Product positioning and messaging direction
- Which recommendations to act on (and when)
- When to create G2/Capterra profiles (we waited 4 weeks too long)
- Content strategy direction (doubling down on Claude Code content)
- Backlink strategy and domain authority plays
The AI generated the analysis and did the execution. Humans set the strategy and made the judgment calls. This is the right split — AI is excellent at systematic research, content production, and tracking. Humans are better at strategic prioritization and knowing when the data is pointing in the wrong direction.
## What Worked
1. Technical SEO before content.
JSON-LD, robots.txt rules for AI bots, and title/meta optimization gave us a foundation that amplified everything that came after. Structured data made our pages eligible for rich snippets. AI bot rules made our content available for citation.
2. The business-angle content strategy.
"Claude Code for Founders" outperformed "Claude Code for Beginners" on CTR by 10x. Targeting a specific persona with a specific use case beats targeting a generic tutorial audience every time. Our best-performing content answered the question "how does this help my business?" not "how does this technology work?"
3. Comparison content
It gets indexed fastest. Our "Duet vs X" guides appeared in search results within days. Every other content type took weeks. If you need quick organic visibility, comparison content is the shortest path.
4. Weekly tracking, automated reports.
The AI agent generated a structured report every week with consistent metrics, flagging regressions and opportunities. This cadence meant we caught the "position 1, 0% CTR" problem within a week of it appearing instead of finding it in a quarterly review.
5. Publishing perfection over publishing velocity.
Thirty posts in one day is extreme. Most had titles that were too long. Some needed meta description work. But they started indexing immediately, and we could optimize after publication. Waiting for perfection would have delayed the entire growth curve by weeks.
6. Title length is the highest-leverage CTR fix. We proved this with hard data: shortening one title doubled its CTR and increased clicks 57%, despite losing impressions. A title that fits in Google's display window beats a descriptive title that gets cut off. Every time.
## What Didn't Work
1. AI citation rate plateaued at 22%. Brand queries work. Category queries don't. Every non-branded AI search returns listicles from G2, Capterra, and established platforms. Without review site presence, there's a hard ceiling on AI visibility.
2. We waited too long on G2 and Capterra. The agent recommended creating profiles in week 1. We actually did it in week 5. Four weeks of missed opportunity for third-party discovery and AI citation improvement.
3. Brand name collision. "Duet" competes with Google's former Duet AI, Duet Display, a dating app, and a PM tool. Our homepage impressions dropped 45% in one week as Google resolved its own Duet AI brand confusion — and pulled our traffic down with it. There's no fix for this except building enough branded search volume that Google learns the intent.
4. Blog post titles over 60 characters. Twenty-two of our 30 blog posts had titles that get truncated in search results. This suppresses CTR from day one. We should have enforced a character limit in the content pipeline before publishing.
## The Playbook
If you're a startup trying to grow organic traffic with AI, here's the sequence:
1. Audit first. Run a full technical SEO audit before writing any content. Missing structured data, broken meta tags, and missing AI bot rules are silent killers.
1. Add structured data on day one. JSON-LD for your homepage (Organization, SoftwareApplication), content pages (Article, TechArticle, FAQPage), and listing pages (CollectionPage, ItemList). This makes every page machine-readable.
1. Let AI bots crawl your content. Update robots.txt to explicitly allow GPTBot, PerplexityBot, ClaudeBot, and other AI crawlers. You want to appear in AI-generated answers.
1. Find your content wedge. Don't write generic content. Find the intersection of a keyword with search volume, a specific persona, and a specific use case. Our wedge was "Claude Code for business users" — not "Claude Code tutorial."
1. Ship comparison content early. "Your Product vs X" pages get indexed fastest and directly target high-intent queries. Publish 3–5 comparison guides in week one.
1. Publish in volume, optimize after. Get content indexed first. Fix titles, meta descriptions, and CTR issues once you have data. Perfection before publication is the enemy of growth.
1. Track weekly. Automated weekly reports with consistent metrics. Week-over-week trends show you what's working faster than monthly reports ever will.
1. Keep every title under 60 characters. This is the single highest-ROI optimization we found. A truncated title kills CTR before anyone reads your content. Enforce this as a hard rule in your content pipeline.
1. Structure pages for section indexing. Use clear, descriptive headings with anchor IDs. Google may index individual sections of well-structured pages as separate search results — giving you multiple entries from a single piece of content for free.
1. Get on third-party platforms immediately. G2, Capterra, Product Hunt — these dominate AI citation results for category queries. Create profiles on day one, not week five.
## The Numbers
Total cost: API fees for DataForSEO, Firecrawl, and AI model usage. Under $200 for six weeks of work that would have cost $18,000–$42,000 at agency rates.
The growth isn't stopping. Those 34 blog posts are still getting indexed. The structured data is compounding. And the AI agent is still running weekly audits, flagging opportunities, and shipping improvements.
We didn't replace our SEO agency. We never needed one.
## Frequently Asked Questions
## Can AI genuinely drive organic traffic growth at this scale?
Yes, the 800% growth case is real and repeatable. AI removes the main bottleneck in SEO: content production velocity. Most sites rank for less than 5% of the keywords they could reasonably target. AI lets you produce quality content for hundreds of keywords in the time it used to take to write 5-10 posts manually.
## Does AI-generated content actually rank on Google?
Yes, when it meets quality standards. Google does not penalize AI content; it penalizes thin, unhelpful, or duplicate content regardless of authorship. AI-produced content that is accurate, well-structured, and comprehensive ranks fine.
## How do I avoid an AI content strategy getting penalized by Google?
Avoid publishing AI content without editing, targeting extremely competitive head terms with thin content, and mass-publishing identical template-style posts. AI content works when it is accurate, specific, and differentiated from what is already ranking.
## How long does it take to see results from an AI content strategy?
New content typically takes 3-6 months to rank in competitive niches. The 800% in 6 weeks case worked because the site had existing domain authority and targeted lower-competition long-tail terms. New sites should budget 6-12 months.
## What content strategy drives the fastest traffic growth with AI?
Topic cluster architecture. Start with 5-10 pillar pages, then use AI to produce 20-50 supporting articles per cluster targeting long-tail variations. Internal link everything to the pillar. Google rewards topical authority, and AI lets you build it fast.
## What is the single most important factor in an AI SEO content strategy?
Keyword intent matching. Before producing any content, verify the SERP for your target keyword and match the format already ranking, whether that is a list post, comparison, guide, or tool page. Start from alignment with Google's existing preferences.
---
Source: https://duet.so/blog/how-we-turned-github-history-into-automated-newsletter
# How We Automated Our Weekly Product Newsletter With AI
*Two hours to write one newsletter. Every week. Here's how Duet automated it — and how you can do the same for any recurring update.*
By Sawyer Middeleer. Published 2026-03-13, updated 2026-05-08. 6 min read.
**Quick Summary**
This guide covers how the Duet team automated their weekly product newsletter using AI, including the workflow, tools, prompts, and time savings so you can replicate the same system for your own newsletter.
**Questions this page answers**
- How to automate a product newsletter with AI
- Best AI tools for newsletter automation
- How to use AI to write a weekly newsletter
- Can AI fully automate newsletter creation?
- What does an automated newsletter system look like?
Every week, our team ships new features.
Every week, someone has to write the newsletter.
Look through what changed, pick the highlights, write the copy, format the email, upload it to the email platform, send a test, tweak it, and finally hit send.
It takes a couple hours. It's important work keeping users in the loop drives retention and engagement. But it's repetitive, and the information is already sitting right there in our project history.
So we taught our AI agent to do it.
## The Problem With Manual Newsletters
Our weekly product update follows a simple pattern: look at what the team shipped, pick the top 5 things users will care about, describe them in plain language, and send it out.
The inputs are predictable (what we built this week), the format is consistent (a branded email), and the audience is the same (our user list). This is exactly the kind of task AI should handle.
The real friction wasn't the writing, it was the context switching. Someone had to stop what they were working on, review a week of changes, translate technical updates into language customers understand, open the email platform, format everything, test the email, and manage the back-and-forth. All for something that follows the same structure every single time.
## How We Set It Up
The setup was surprisingly simple. We use Resend for sending emails and Duet as our AI workspace. Here's what we did:
1. Connected the email tool. We installed Resend's command-line tool in our Duet workspace and logged in. This is a one-time setup think of it like connecting a new app to your phone. Once it's linked, the AI agent can create drafts, send previews, and manage your email list without you touching the email platform.
2. Taught the agent the workflow. We saved a simple Markdown playbook in workspace Files describing the newsletter process in plain English: which email list to use, what the template looks like, where to find the week's updates, and rules such as "always create a draft first; never send without approval." You don't need to write code. You're describing the process the way you'd explain it to a new team member.
3. Scheduled it. We set a weekly timer (Duet has built-in scheduling) so the agent runs the workflow every Thursday morning automatically.
That's it. No programming. No API integrations to build. Just connecting a tool, writing instructions, and setting a schedule.
## What Happens Every Thursday
Here's the workflow that runs automatically each week:
### The agent reviews what shipped
It looks through the team's project history from the past 7 days — every feature added, bug fixed, and improvement made. This is the raw material.
### It picks the highlights and rewrites them
The agent reads through everything and translates technical updates into benefits users actually care about. For example, a developer might log a change as "add infinite scroll to threads tab." The agent turns that into:
> Smoother Thread Browsing Threads now load continuously as you scroll. No more clicking "load more" to find older conversations.
It picks the top 5 most impactful changes, focusing on things users will notice right away rather than behind-the-scenes improvements.
### It builds a branded email
Using our newsletter template (with our logo, colors, button styles, and footer already baked in), the agent assembles a complete, styled email. If screenshots are available, it includes those too.
### It creates a draft never sends directly
This is a key safety rule we built in. The agent creates a draft in Resend and sends a preview to my inbox. It never blasts the full list without a human saying "go."
### I review and give feedback
A preview lands in my inbox. I look it over and can request changes in plain English — "lead with the dashboard feature instead," "remove the second screenshot," "make the intro punchier." The agent makes the edits, creates an updated draft, and sends a new preview.
### I say "send it" and it goes out
Once I'm happy with it, I reply "send it" and the agent sends the newsletter to our full user list. The entire back-and-forth usually takes about 5 minutes of my time down from 2 hours of manual work.
## Why This Works So Well
The information already exists. Every team tracks what they're working on somewhere—project management tools, shared docs, chat history, or (in our case) a code repository. The newsletter isn't new content. It's a curated summary of work that's already been done. AI is great at summarizing.
The format never changes. A weekly newsletter has the same structure every time: greeting, top updates, maybe a screenshot or two, a call to action, footer. Once you define the template, the agent fills in the blanks.
A human stays in the loop. The agent does the heavy lifting, but a person reviews every email before it goes out. This catches anything the AI gets wrong and lets you add your own voice. It's automation with a safety net.
## You Can Set This Up Today
This pattern works for any recurring communication that follows a predictable format:
- Weekly product updates from your project board or changelog
- Internal team digests summarizing what everyone accomplished
- Customer announcements when you launch new features
- Monthly recap emails pulling from your activity over the past 30 days
The key ingredients are:
1. A source of information the AI can read (project history, a task board, a shared doc, meeting notes)
1. A template that defines what the email should look like
1. An email platform for sending (we use Resend, but any platform with a similar tool works)
1. An AI agent that can tie it all together on a schedule
In Duet, this means saving an instruction file in workspace Files, connecting your email tool through Integrations, and setting the cadence. The agent handles the rest: reading updates, writing and formatting the email, and creating a draft for review.
The whole setup takes about 30 minutes. After that, your newsletter writes itself every week. You just review and approve.
---
We built this with Duet, a cloud workspace where your AI agent has memory, tools, scheduling, and everything it needs to handle recurring work like this. If your weekly newsletter is eating hours you'd rather spend building, give it a try.
---
Source: https://duet.so/blog/kimi-k3-open-source-ai-models
# Open Source AI Models for Business: Is Kimi K3 the End of the Per-Seat AI Bill?
*Kimi K3 launched open-weight. Here's the seats-vs-tokens math: when per-token AI pricing beats fixed seat subscriptions for SMB teams.*
By Duet Team. Published 2026-07-17, updated 2026-07-17. 12 min read.
## When per-token AI beats per-seat pricing
Per-token AI is cheaper than per-seat when your team's real monthly work costs less than the fixed seat bill for the same people. Multiply seats by monthly seat price for the subscription side; multiply input, output, and cached tokens by their rates for the usage side. When use is light or mixed, usage usually wins if assumptions stay visible.
Kimi K3, a frontier-class open-weight model that launched this week, is the clearest live test of that math. It sits in Duet's Standard tier, one of the models the router reaches for on everyday work.
## Why Kimi K3's launch changes your AI bill
Moonshot AI released Kimi K3 on July 16, 2026: a 2.8-trillion-parameter mixture-of-experts model that activates just 16 of its 896 experts per token, with a 1-million-token context window: enough to hold roughly 1,573 pages of text in one pass.
Independent benchmarks (next section) put it near the frontier. But precision matters here: K3 is **open-weight**, not open source today. [Moonshot's own announcement](https://www.kimi.com/blog/kimi-k3) commits to releasing the full model weights by July 27, 2026; for now, it's served only through the API.
That's a real distinction from a model like GLM-5.2, which already ships under a genuine MIT license.
What makes K3 matter for your AI bill isn't the launch itself. It's that frontier-class capability just became available with no per-seat license attached. It's priced instead by the token, the way electricity or bandwidth is.
Duet added K3 to its Standard tier the same week. Capability plus no seat tax is what makes the rest of this article's math possible.
## Are open-weight models good enough for work?
Yes, for the large majority of drafting, research, ops, and reporting work. [Artificial Analysis' independent benchmark](https://artificialanalysis.ai/models/kimi-k3) ranks Kimi K3 at 57 on its Intelligence Index v4.1: #4 of 189 models tracked, behind only Claude Fable 5 (60) and GPT-5.6 Sol (59), ahead of Claude Opus 4.8 (56). That puts K3 ahead of every other open-weights model on the index.
Even Moonshot admits K3 isn't the top model overall: its own blog says performance "still trails the most powerful proprietary models." That's an honest vendor claim worth taking at face value — K3 doesn't need to be #1 to change your bill.
On the benchmark closest to actual knowledge work, AA-Briefcase, K3 scores an Elo of 1,547, a jump of 732 points over Moonshot's prior model. Only Claude Fable 5 ranks higher — that's the number that matters for drafting or research work.
The pattern holds beyond K3. [MIT research on open models](https://mitsloan.mit.edu/ideas-made-to-matter/ai-open-models-have-benefits-so-why-arent-they-more-widely-used) found open-weight models now average 89.6% of closed-model performance, closing the gap to a new closed release within roughly 13 weeks. Optimal routing to open models, by MIT's estimate, could save businesses up to ~$25B a year, industry-wide.
Featherless's CEO summed up the practical takeaway: most open models run "N-1" behind the leader, "and N-1 is fine" for the bulk of business work. For more on how we test models against real work instead of invented prompts, see [how we evaluate models on real work](/blog/how-we-benchmark-ai-models-on-real-work).
## What your team really spends on AI seats
Take a real team. Maya runs ops for a 5-person boutique event-services company. Nobody on her team writes code. They draft client proposals, research vendors and competitors, run weekly ops checklists, and put together monthly reports.
Here's what Maya's team pays today, seat by seat:
| Role | Tool/tier | Seats | Price/seat/mo | Subtotal |
| ------------------------- | --------------------------- | ----: | ------------: | ----------: |
| 3 team members | ChatGPT Business (Standard) | 3 | $25 | $75 |
| Ops lead + reporting lead | Claude Team (Premium) | 2 | $125 | $250 |
| **Total seat bill** | | **5** | | **$325/mo** |
Those aren't inflated numbers: ChatGPT Business runs $20–25/user/month; Claude Team runs $20–25 Standard or $100–125 Premium. Two people on Premium for research and reporting is common, not an edge case.
That $325 bills the same in a slow week as a busy one. A seat is a fixed, provisioned-per-human cost, owed whether the person opens the app once or fifty times that month.
## What that same work costs per token
Now price that exact same month of work by the token, at Kimi K3's real Duet rates: $3 per million input tokens, $15 per million output tokens, $0.30 per million cached input tokens.
Here's Maya's team's actual monthly volume, with every assumption labeled:
| Work type | Volume/mo | Assumption | Tokens |
| ----------------------------------- | --------- | --------------------------------------------------------- | ------------------------------------------------ |
| Drafts (emails, proposals, updates) | ~440 | ~700 words in, ~900 words out | 410K in / 527K out |
| Research briefs | ~66 | ~10K words cached background + ~1.5K new, ~1.8K words out | 878K cached / 132K in / 158K out |
| Ops checklists | ~220 | ~300 words in, ~200 words out | 88K in / 59K out |
| Monthly reports | 4 | ~20K words cached prior data, ~2.4K words out | 106K cached / 13K out |
| **Total** | | | **630K uncached in / 1.0M cached in / 760K out** |
Priced at Kimi K3's rates:
| Token type | Volume | Rate/1M | Cost |
| -------------------- | -----: | ------: | --------------: |
| Uncached input | 0.63M | $3.00 | $1.89 |
| Cached input | 1.0M | $0.30 | $0.30 |
| Output | 0.76M | $15.00 | $11.40 |
| **Total usage bill** | | | **≈ $13.60/mo** |
That $13.60 covers the same ~730 pieces of work the $325 seat bill covered. Nothing was rationed. The research briefs and reports lean on caching because they reuse the same client and vendor background repeatedly. That's how agentic work actually runs, not a trick.
## Seats vs tokens: which wins for your team?
This isn't hypothetical: [NPR reported](https://www.npr.org/2026/07/15/nx-s1-5886476/startups-cheap-chinese-ai-models) that Lindy.ai switched its traffic to a metered model after its AI bill became "by far" its No. 1 expense, cutting costs roughly 10x.
Put Maya's numbers side by side with the general shape of the decision:
| | Per-seat (fixed) | Per-token (usage) |
| -------------------- | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------- |
| What you pay for | A person having access | Work actually run |
| Predictability | Same bill regardless of use | Scales with volume |
| Idle cost | Full price even unused | $0 if no work runs |
| Heavy vs. light user | Same price either way | Heavy user pays more, light pays less |
| Typical price today | ChatGPT Business $20–25/user/mo; Claude Team $20–25 Standard / $100–125 Premium | Kimi K3 runs in Duet's Standard tier: $5/1M input, $0.50/1M cached, $30/1M output |
| Best fit | One person using it constantly | Multiple people, spiky or occasional use |
The rule underneath the table: a seat only earns its keep once a person's real usage would cost more metered than the seat itself. For Maya's team, that threshold sits at roughly **20–25× today's actual volume**: tens of millions of output tokens a month, sustained.
For most non-technical work like this, that line rarely gets crossed outside an agent running near-continuously.
## Is Kimi K3 the cheapest model to route to?
No. Worth saying plainly. At $3/1M input and $15/1M output, Kimi K3 is priced near frontier rates, not floor rates. On provider rates, GLM-5.2 ($1.40/$4.40/$0.26) and Grok 4.5 ($2/$6) are both cheaper.
K3 costs what it costs because it performs close to what it costs. [The Decoder's analysis](https://the-decoder.com/kimis-open-model-k3-nears-gpt-5-6-sol-and-fable-5-while-signaling-the-end-of-super-cheap-chinese-ai/) puts K3's cost-per-task at $0.94, close to GPT-5.6 Sol's $1.04, about half Opus 4.8's $1.80, but still well above GLM-5.2's $0.32 and DeepSeek V4 Pro's $0.04. As the piece frames it, this is the end of super-cheap Chinese AI.
There's a real caveat too. On an adversarial knowledge-probing benchmark (AA-Omniscience), K3's hallucination rate rose to 51%, up from 39% on its predecessor, even as its raw accuracy improved from 33% to 46%.
That's one narrow, adversarial eval, not a claim that K3 gets facts wrong half the time. It's a reason to keep a human reviewing anything client-facing, not a reason to skip the model.
The savings story here was never about finding the cheapest token. It was about killing the seat tax and paying only for real usage.
## How to route work across AI models
The answer isn't picking one model and living with it forever. It's routing: send routine work to a balanced model by default, and send the specific tasks that need more to a frontier model, one click at a time.
Concretely: drafts, research, ops checklists, and reports default to Balanced. A high-stakes deliverable or long-horizon analysis escalates to frontier for that one task, not the whole team.
This is exactly the mechanism a managed multi-model workspace is for. In Duet, Kimi K3 is one of the models behind the Standard tier: routine drafts, research, ops checklists, and reports route to it automatically. When a task actually needs more, you move that session to the Max tier, mid-session, without losing context or starting a new subscription.
There's no seat to provision for the switch and no separate bill to reconcile. Every model behind a tier, from Kimi K3 to Claude Opus 4.8 to GPT-5.6 Sol, bills at that tier's flat token rate, so moving a task changes the rate rather than the number of subscriptions.
[Duet's pricing page](/pricing) shows each quality tier's token rate and a sample month's bill itemized to the cent, plus a 7-day free trial with no card required, so you can run your own team's numbers first.
## When to still pay for a frontier model
Frontier models earn their higher price in three places: the hardest long-horizon reasoning, the highest-stakes client-facing deliverables, and anything where a small accuracy gap costs real money: a legal-adjacent clause, a board-level analysis, a make-or-break pitch.
That's where K3's hallucination caveat from the last section actually matters. On work where being wrong is expensive, route it to Claude Opus 4.8, GPT-5.6 Sol, or Claude Fable 5 instead, and pay the premium on purpose.
Frontier isn't obsolete. It's just not the default for the routine work that fills most of a non-technical team's month. Match the model to the stakes of the task, not to habit or to whichever subscription happens to be open. For a deeper walkthrough of matching models to tasks, see [choosing the right AI model for your business](/blog/how-to-choose-the-right-ai-model-for-your-business).
## Frequently asked questions
### Is Kimi K3 open source?
Not yet, precisely. Kimi K3 is open-weight. Moonshot has committed to releasing the full weights by July 27, 2026, but at launch it's served only through the API. That's different from GLM-5.2, which already ships under a genuine MIT license.
Both are "open" in the sense that matters for cost: no single vendor controls who can serve them.
### Is Kimi K3 the cheapest AI model?
No. At $3/1M input and $15/1M output, K3 is priced near frontier rates: on provider rates GLM-5.2 ($1.40/$4.40) and Grok 4.5 ($2/$6) are both cheaper. K3's price reflects near-frontier performance, not a budget position. The savings story in this article isn't about picking the cheapest token.
### How much do AI tokens actually cost compared to a seat subscription?
It depends entirely on how much you use the seat. A seat costs the same $20–125/month whether one person uses it constantly or barely opens it.
Token pricing charges only for what you actually send and receive. For most non-coding work, that's typically a small fraction of the equivalent seat bill.
### What kind of work is safe to route to a balanced open-weight model like Kimi K3?
Routine business work: drafting emails and proposals, first-pass research and account briefs, operations checklists, and recurring reports. These are high-volume, lower-stakes tasks where the gap between a #4-ranked model and a #1-ranked model doesn't show up in the output.
### When should I still use a frontier model instead?
For the hardest long-horizon reasoning, the highest-stakes client-facing work, and anything where a mistake is expensive: legal-adjacent drafts, board-level analysis, a make-or-break pitch. Route those specific tasks to the Max tier and keep everything else on Standard.
### How do I actually try this without ripping out my current AI subscriptions?
Start by mapping what your team's seats cost per month against what the same work would cost metered. The worked example above is a template.
Duet's pricing page shows the quality tier Kimi K3 sits in, its token rate, and a 7-day free trial with no card required, so you can run the comparison against your real workload before changing anything.
---
Source: https://duet.so/blog/loops-vs-duet-boards
# Loops vs Duet Boards — How to Run Autonomous Workflows Without Writing a Single Script
*Peter Steinberger says design loops, not prompts. Here's what that means if you're not a developer — and how Duet Boards let you run it without code.*
By Duet Team. Published 2026-06-08, updated 2026-06-08. 14 min read.
> You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents.
> — Peter Steinberger, [June 7, 2026](https://x.com/steipete/status/2063697162748260627)
That tweet [cleared 2.2 million views](https://x.com/mvanhorn/article/2063865685558903149) in under 24 hours. Boris Cherny, who created Claude Code (which reportedly accounts for ~4% of all public commits on GitHub), put it more bluntly at a conference days earlier: "I don't prompt Claude anymore. I have loops running that prompt Claude and figure out what to do. My job is to write loops."
Here's the problem: both Steinberger and Cherny are developers. They're talking about writing code — server processes, cron jobs, state variables, cloud deployments. The "design loops" moment is real and it matters. But the entire conversation has been in developer.
This article is the translation layer. Duet Boards are that translation.
A loop, as Cherny described it, is conceptually simple: a small program that prompts the agent, reads the output, decides if the task is done, and re-prompts if not. That's the whole thing. The intelligence lives inside the body of that cycle — not in the cycle itself.
The AI industry is moving through three stages. First: manually prompting one agent at a time. You're the engine — every step requires your attention. Second: parallel sessions — multiple agents running simultaneously, but you're still steering each one. Third: loops with self-verification — agents that prompt themselves on triggers, check their own output, and advance without you. Most operators are stuck at stage one or two. Steinberger and Cherny have already moved to three.
A Kanban board is a loop. You've been designing them for years. Duet just adds the AI.
---
## What Is a No-Code AI Agent?
**What is a no-code AI agent?**
A no-code AI agent is an autonomous workflow that runs itself through a defined sequence of tasks — without any programming required. Instead of writing scripts, you design stages on a visual board. The AI executes each stage, makes decisions, and advances the workflow automatically — the same way a developer's loop works, but built for operators.
That distinction matters. Most people who hear "AI agent" picture a chatbot — one question, one answer, conversation over. Or they picture a Zapier automation — if X happens, do Y, branch stops. An AI agent is neither.
[Simon Willison](https://simonwillison.net/2025/Sep/30/designing-agentic-loops/), one of the most cited practitioners on how AI systems actually work, defines an agent as "something that runs tools in a loop to achieve a goal. The art of using them well is to carefully design the tools and loop for them to use." The key word is loop.
The contrast that makes it click:
- **Chatbot:** You ask → it answers → done. One shot, no persistence.
- **Automation tool (Zapier, Make):** Trigger fires → follow the script → stop. Predetermined branches, no reasoning.
- **AI agent:** Goal set → agent acts → agent checks → agent decides next step → continues until done. Adaptive, self-directing, persistent.
No-code just means you build it on a visual board instead of writing Python. The underlying architecture — what Boris Cherny calls a "loop" — is identical.
---
## Wait — Isn't a Kanban Board Already a Loop?
Yes, literally.
Every well-designed Kanban board is already a state machine. Each column is a state, each card is a unit of work moving through states, and moving a card is a state transition. Exit criteria define when the card can advance. A "Blocked" column is an escalation path. A "Done" column is the stop condition.
Boris Cherny designs loops to manage software. You already design loops to manage your business — you just call them Kanban boards.
The translation is exact:
| Developer says… | Operator calls it… | In Duet it's… |
| ------------------- | -------------------- | ---------------------------------------- |
| "Write a loop" | "Set up a workflow" | "Create a Board" |
| "State" | "Stage / column" | "Board column" |
| "State transition" | "Moving a card" | "Card moves to next column" |
| "Agent" | "Person responsible" | "AI assigned to this column" |
| "Stop condition" | "Exit criteria" | "Terminal column (Done/Blocked)" |
| "Durable execution" | "It runs itself" | "Duet cloud keeps it going" |
| "Escalation path" | "Needs a human" | "`Blocked` column surfaces the decision" |
The two sides have been describing the same pattern in different languages. The only difference is who — or what — executes the transitions. Duet makes the columns executable by an AI agent instead of a person.
---
## What Makes an AI Loop Different From Regular Automation?
If you already use Zapier or Make, you have a reasonable question: isn't this just the same thing with better branding?
It isn't. Here's the precise difference.
Zapier follows a predetermined code path. You define every branch in advance: if field contains "billing," route to billing@. The script is complete before any email arrives. If an angry enterprise trial user emails asking how to export their data before canceling — Zapier routes it to billing@. Because that's what the script says.
An AI loop reasons at each step. It reads the full email, checks account tier, scores sentiment, identifies the real intent — and routes based on understanding, not keyword matching. Situations the original script never anticipated get handled. They're not errors; they're just inputs.
[Oracle's breakdown of the agent loop architecture](https://blogs.oracle.com/developers/what-is-the-ai-agent-loop-the-core-architecture-behind-autonomous-ai-systems) puts the technical structure plainly:
```
while not done:
response = call_llm(messages)
if response has tool_calls:
results = execute_tools(response.tool_calls)
messages.append(results)
else:
done = True
```
Non-technical translation: "While the task isn't finished — ask the AI what to do next, do it, remember what happened, then loop back."
The decision-making inside each iteration is what separates a loop from a script. Zapier executes instructions. An AI loop exercises judgment.
A related objection comes up with developers: "isn't this just a cron job with rebranding?" Close, but no. A cron job runs a fixed script on a schedule. A loop uses the same trigger mechanism but puts a decision-maker — an LLM — in the body. Same heartbeat. Fundamentally different body. The cron job executes whatever you wrote. The loop reads the current state, reasons about the best next action, and adapts to what it finds. That reasoning step is the entire difference between automation and agency.
If you want to compare the full landscape, the [no-code AI agent builders](/blog/6-best-ai-agent-builders-in-2026) category now runs from simple trigger-and-action tools to platforms that reason at each stage — and the gap between them is exactly this.
---
## What Are the Four Things That Make a Loop Actually Work?
Every real AI loop has the same four mechanics. Miss any one and you get something that either breaks mid-task, spins endlessly, or stops the moment you close your laptop.
### 1. Persistent State — the loop remembers where it is
The loop carries what it knows forward. Each iteration builds on the last.
In a content pipeline, when a card moves from "Written" to "Revision," the editor's feedback travels with it. The AI revising the piece isn't guessing what needs to change — it's reading the specific feedback that accumulated in the previous stage. A chatbot doesn't do this. A cron script starts from zero every time. A loop accumulates.
### 2. Decision at Each Step — AI reasons, doesn't just follow branches
At every iteration, the agent evaluates what it sees and chooses what to do next. This is the core break from if-this-then-that automation.
The support ticket example is clean: a rules-based system routes by keyword. An AI loop reads the whole email, checks account tier, reads tone, identifies the actual question — and routes based on that reasoning. "Angry enterprise trial user asking how to export data before canceling" is not a branch the original script covered. The loop figures it out.
### 3. Conditional Continuation — AI decides whether to keep going or stop
A loop that never stops is AutoGPT circa 2023. A well-designed loop knows its exit conditions.
Geoffrey Huntley's [ralph technique](https://ghuntley.com/ralph/) — a structured methodology of piping a fixed anchor prompt file into the agent on repeat, resetting context to fixed specification files each iteration — produced an entire programming language for roughly $297. The loop ran until the specs were met. Then it stopped. Clear exit conditions are what made that possible and what keep loops from becoming runaway processes.
### 4. Durable Execution — runs even when you're not watching
Boris Cherny closed his laptop. 259 PRs landed in 30 days. That doesn't happen if the loop only runs while someone is watching the terminal.
Real loops run on a server. They persist across sessions, execute on a schedule, and pick up where they left off if something interrupts them. You get involved when a decision requires human judgment — not to press "go again" every morning.
---
## How Do Duet Boards Run All Four Mechanics Without Code?
When a card lands in the "Research" column of a content pipeline board, the agent assigned to that column reads the brief, runs web searches, pulls competitor data, and writes a structured research summary — then moves the card to "Draft" automatically. You didn't write a function. You didn't configure a webhook. You described what should happen in plain English, and Duet turned it into a running workflow.
Every column maps to one of the four loop mechanics. The card itself is the persistent state — every piece of context the agent adds accumulates and is available to the next stage. The agent at each column is the decision-maker — it reasons about what the card contains, not a script. The terminal columns (Published, Shelved, Blocked) are the stop conditions — the loop knows when it's done. And the whole thing runs on Duet's cloud, not your laptop — durable execution that keeps going over the weekend.
Prefer an [always-on AI agent](/blog/how-to-set-up-a-24-7-ai-agent) approach? Start from [setting up Duet](/guides/how-to-set-up-duet) and build your first board in under 10 minutes.
---
## What Workflows Can I Actually Build This Way?
Loops work best for tasks with a clear goal, natural stages, and a mix of AI-executable steps and human judgment calls at key decision points.
| Workflow | Columns | AI handles | Human handles |
| ---------------------- | -------------------------------------------------------------- | ---------------------------------------------- | ------------------------------------- |
| **Content pipeline** | Research → Draft → Review → Revise → Published | Research, drafting, revision edits | Final approval, editorial escalations |
| **Support triage** | Inbox → Classify → Route → Respond → Closed / Escalated | Classification, routing, draft responses | Escalated tickets, enterprise issues |
| **Lead qualification** | New Lead → Enrich → Score → Qualified → In Sequence → Won/Lost | Enrichment, scoring, sequencing | ICP edge cases, high-value deals |
| **Invoice processing** | Received → Extract → Match → Approved / Flagged → Paid | Extraction, line-item matching, approval queue | Flagged invoices, vendor disputes |
Each of these runs the same way: describe what should happen at each column in plain English, assign an AI to the automated steps, and define when a card should advance or escalate.
For teams that want to [automate content creation without a team](/blog/how-to-automate-content-creation-one-person-business), the content pipeline is usually the fastest to build — the stages already exist in your head, you just haven't made them executable yet.
Once you're running multiple workflows, keeping everything in one place makes the difference between a few working automations and a real operating system for your business. Building an [AI command center](/guides/how-to-build-your-ai-command-center) — all your boards, agents, and scheduled tasks in a single workspace — is what that looks like in practice.
---
## Do I Actually Need to Understand AI to Design a Loop?
No. You need to understand the workflow, not the AI.
A developer building a loop from scratch writes a trigger, system prompts for each step, tool call definitions, state variables, stop conditions, failure handling, and cloud deployment. That's hours to days of work, and it requires knowing Python or Node.js.
A Duet user building the same loop: creates a Board, names the columns, assigns an agent to each automated column, and writes a plain-English description of what the agent should do. Duet handles the state machine, the scheduling, the cloud runtime, and the execution.
Even experienced developers prefer simpler loop-design interfaces when they're available. Geoffrey Huntley's [ralph technique](https://ghuntley.com/ralph/) wasn't born from a love of complexity — it replaced manual, repetitive iteration with a structured repeatable pattern precisely because simpler is always preferable when simple works.
Peter Steinberger said "you should be designing loops." He didn't say you need to write them. Duet writes them for you.
The skill that matters isn't programming. It's knowing your workflow well enough to describe what should happen at each stage.
---
## Frequently Asked Questions
**What is a no-code AI agent?**
A no-code AI agent is an autonomous workflow that runs itself through a defined set of tasks
without any programming required. You design the stages on a visual board; the AI executes each
one, makes decisions, and advances the workflow automatically — the same architecture developers
call an "AI loop," built for operators instead of engineers.
**What is the difference between an AI loop and regular workflow automation?**
Regular workflow automation (like Zapier or Make) follows predetermined branches — if condition
A, take action B, as scripted in advance. An AI loop reasons at each step: it reads the current
state, evaluates context, and decides what to do next — including handling situations the
original workflow never anticipated. The decision-making in the middle is the difference. Zapier
automates scripts; AI loops automate judgment calls.
**Do I need to code to build an AI agent workflow?**
No. Platforms like Duet let you describe what each stage of a workflow should do in plain
English. You name your columns, assign an agent to each automated step, and define the handoff
criteria. Duet handles the state machine, scheduling, cloud runtime, and execution. No script
required.
**What is the best no-code AI agent builder?**
It depends on what you're automating. For simple trigger-and-action tasks, Zapier or Make work
well. For multi-stage workflows that run autonomously over hours or days — with persistent
memory, reasoning at each step, and human-approval gates — Duet is purpose-built for that use
case. See the full comparison of [no-code AI agent
builders](/blog/6-best-ai-agent-builders-in-2026) for a detailed breakdown of the category.
**How does Duet run autonomous workflows?**
Duet uses a board-based state machine where each column is a workflow stage and each card is the
unit of work moving through it. An AI agent assigned to each column reads the card, takes
action, and advances or escalates based on the handoff criteria you define in plain English. The
whole thing runs on Duet's cloud — persistent, durable, and scheduled.
**What business workflows can I automate with a no-code AI agent?**
Any workflow with clear stages and a mix of repeatable steps and judgment-heavy exceptions.
Common patterns: content pipelines (research → draft → review → publish), support triage
(classify → route → respond → close), lead qualification (enrich → score → sequence → won/lost),
and invoice processing (extract → match → approve → pay). The AI handles repeatable steps;
humans handle the exceptions.
**What is an AI loop in simple terms?**
An AI loop is a workflow where an AI agent takes an action, checks what happened, decides
whether the job is done — and if not, takes the next action entirely on its own. You define the
goal and the stages once. The AI keeps going until the work is finished or until it surfaces a
decision that genuinely needs a human. Then it stops and waits.
---
Source: https://duet.so/blog/mcp-alternatives-code-execution-agents
# Why We Replaced MCP With Code Execution Agents
*MCP looked promising. Then we tried code execution agents and never looked back. Here's what changed our minds.*
By Sawyer Middeleer. Published 2026-03-06, updated 2026-05-08. 10 min read.
# Why We Replaced MCP With Code Execution Agents
When we first built Duet's agent infrastructure, we leaned heavily on MCP, Model Context Protocol.
It was clean, well-documented, and felt like the right abstraction layer for connecting AI models to external tools.
For simple tool use, it worked well.
But as our workflows got more complex, multi-step automations, conditional logic, error handling, dynamic tool creation, MCP started showing its limits.
The stateless architecture that made it predictable also made it brittle for anything non-trivial.
We eventually moved to code execution agents, and the difference was significant.
This post explains exactly why, when MCP still makes sense, and what we'd recommend for teams building production AI workflows in 2026.
Quick Summary
This post explains why the Duet team moved away from MCP (Model Context Protocol) toward code execution agents, covering MCP's limitations, what code execution agents do better, and when each approach makes sense.
Questions this page answers
- What is the difference between MCP and code execution agents?
- Why replace MCP with code execution agents?
- What are the limitations of MCP in AI workflows?
- How do code execution agents work?
- What is Model Context Protocol (MCP)?
---
## The MCP Context Bloat Problem
MCP (Model Context Protocol) is the standard way AI agents connect to external services. The pattern: define a set of tools with schemas, inject them into the agent's context, and let the agent call them.
It works. Until it doesn't.
The problem is linear context cost. Every MCP tool you add, its name, description, parameter schema, examples, takes up space in the agent's context window. Connect 10 services with 5 tools each, and you've burned thousands of tokens before the agent has done anything useful.
This creates a painful tradeoff:
- Load everything upfront and accept degraded performance on the actual task (less room for reasoning, conversation history, and working memory)
- Limit integrations and accept that your agent can only talk to a handful of services
- Build dynamic tool loading and accept the latency and complexity of tool-selection middleware
None of these are great. The context window is the most valuable real estate your agent has. Filling it with tool definitions it might never use is wasteful.
Beyond context costs, MCP has other limitations that become clear at scale.
Each tool only exposes what the original developer chose to include. Need a parameter the tool author didn't anticipate? You're stuck. Need to combine three API calls into one atomic operation? The tool abstraction gets in the way.
## Agents That Write Their Own Integrations
What if the agent didn't need pre-defined tools at all?
Here's the approach we landed on: instead of injecting MCP tool definitions, give the agent a persistent server environment where it can write and execute code. When the agent needs to interact with an external service, it:
1. Looks up the API: reads docs, finds endpoints, understands auth
1. Writes integration code: a Python or TypeScript script that calls the API directly
1. Executes it: runs the code on its server, gets results
1. Saves it: stores the working code in its persistent memory for next time
The next time the agent needs that integration, it doesn't re-discover anything. It loads its saved code and runs it. Over time, the agent builds a growing library of integrations it wrote itself.
The context cost? Zero at startup. The agent only loads what it needs, when it needs it.
## MCP vs Code Execution
This isn't just a performance optimization. Code execution is fundamentally more capable than MCP tools across every axis that matters for production AI agents.
Consider a concrete example. An MCP tool for a project management service might expose createissue, listissues, update_issue, a fixed set of operations. An agent writing its own integration can hit any API endpoint, combine multiple calls into a single operation, transform data between formats, and handle edge cases the tool author never anticipated.
The agent isn't limited to what someone pre-built. It has the full power of the API.
## Self-Evolving Software
The most interesting property of this architecture is that the agent improves its own integrations over time.
When an API call fails, the agent debugs it, fixes the code, and saves the improved version. When a workflow needs a new data transformation, the agent writes it and adds it to its library. When a service changes its API, the agent updates its code the next time it runs.
This is self-evolving software. The agent's integration layer isn't static, it grows and adapts with use.
Compare this to MCP tools, which are frozen at the version the developer published. When an API changes, you wait for the tool author to update. When you need a feature the tool doesn't support, you file an issue and wait. The agent is at the mercy of external maintainers.
With code execution, the agent is its own maintainer.
This compounds over time. A 24/7 AI agent running on persistent infrastructure doesn't just execute tasks, it accumulates working integration code, error-handling patterns, and domain knowledge. Each session makes the next one more efficient.
## The Infrastructure Requirement
There's a catch. This architecture requires three things most AI products don't have:
1. A persistent server: somewhere to run code, store files, and maintain state across sessions
1. Memory: a way to save integration code and recall it later without using context window
1. Code execution: a runtime environment with network access, package management, and file system access
This is why session-based AI tools can't do this. ChatGPT, Claude.ai, and most AI assistants spin up a fresh environment each conversation. There's no persistence. No memory. No way to build on previous work.
You need a cloud server that stays on, one where the agent can write a script today and run it next week. Where it can install a package, save credentials, and build up a library of working code over time.
This is the core architectural bet behind Duet. Every user gets a persistent cloud server with an always-on AI agent. The agent has its own file system, memory, scheduled tasks, and code execution environment. It writes its own integrations, saves them, and reuses them. Getting more capable the longer it runs.
It's also why this approach is rare today. Most AI products are stateless by design. Building a persistent, server-backed agent is a fundamentally different infrastructure challenge. One that requires rethinking how AI agent platforms are built from the ground up.
## What About MCP Security?
MCP's security model introduces its own risks. Every MCP server you connect gets access to your agent's context and can execute operations on your behalf. The more servers you connect, the larger your attack surface.
With code execution on a sandboxed server, the agent controls exactly what runs, when, and with what credentials. There's no third-party tool server sitting between your agent and the API. The agent writes direct API calls with explicit authentication, nothing hidden in middleware layers.
This doesn't eliminate security concerns, but it shifts the trust boundary. Instead of trusting dozens of third-party MCP server implementations, you trust one sandboxed execution environment that you control.
## When MCP Still Makes Sense
MCP isn't going away, and it shouldn't. It's a useful standard for specific scenarios:
- Quick prototyping: when you need a working integration in minutes, not hours
- Well-defined, stable APIs: where the tool author's abstraction matches your use case exactly
- Bootstrapping agent capabilities: getting a new agent productive before it builds its own library
- Standardized interfaces: where interoperability between different agent frameworks matters
The Agent Skills 101 guide breaks down the spectrum from simple tool calls to MCP servers to full skill systems. MCP occupies a useful middle ground, it's just not the endgame for production agents that need to work across dozens of services.
## What This Means for the Future of AI Integrations
For production AI agents that need to work across dozens of services, handle edge cases, and improve over time, the future is code execution on persistent infrastructure.
The integration layer of the future isn't a catalog of pre-built tools. It's an agent that can read API documentation and write its own.
This shift has implications for how teams build with AI:
- Stop optimizing for tool count. The number of pre-built integrations a platform offers matters less than whether the agent can write its own.
- Invest in persistence. An agent that forgets everything between sessions can never build a reusable integration library. Cloud-hosted agents with persistent storage are table stakes.
- Think in code, not configs. The most capable agents aren't the ones with the most pre-configured tools. They're the ones with the best code execution environments and the freedom to use them.
Teams already using AI for startup operations, competitive intelligence, and sales prospecting are discovering this firsthand: the agents that write their own integrations consistently outperform those limited to pre-built tool catalogs.
The question isn't whether AI agents will move beyond MCP. It's how fast.
## Frequently Asked Questions
### What is MCP (Model Context Protocol)?
MCP is an open standard for connecting AI agents to external services. It defines a protocol where tools (functions with input schemas) are injected into an agent's context window, allowing the agent to call them during conversations. It was designed to standardize how AI models interact with APIs, databases, and other services.
### What are the main limitations of MCP?
The primary MCP limitations are context bloat (each tool consumes tokens in the agent's context window), limited API coverage (tools only expose what the developer built), rigid parameterization (you can't customize beyond pre-defined inputs), and maintenance dependency (you wait for tool authors to update when APIs change). These compound as you add more integrations.
### Is code execution a complete replacement for MCP?
Not entirely. MCP is still useful for quick prototyping, stable APIs where pre-built abstractions match your needs, and standardized interfaces between agent frameworks. Code execution is better for production agents that need full API coverage, custom logic, and self-improving integrations across many services.
### What infrastructure do AI agents need for code execution?
AI agent code execution requires three things: a persistent server that stays running across sessions, a memory system for saving and recalling integration code, and a runtime environment with network access and package management. This is why most AI chatbots can't do it, they use ephemeral, stateless environments.
### How does code execution improve AI agent security?
Code execution on a sandboxed server shifts the trust boundary. Instead of connecting to dozens of third-party MCP servers (each with access to your agent's context), the agent makes direct API calls from a single controlled environment. You manage one trust boundary instead of many.
### Can AI agents really write their own API integrations?
Yes. Modern AI models can read API documentation, write integration scripts in Python or TypeScript, test them, debug failures, and save working code for reuse. On persistent infrastructure, agents build growing libraries of self-written integrations that improve with each use.
---
Source: https://duet.so/blog/mcp-servers-for-claude-code-examples
# 8 MCP Servers for Claude Code You Can Actually Defend (2026)
*MCP server examples for Claude Code, vetted for safety and maintenance. 8 servers across code, databases, and web grounding, with live-verified install commands.*
By Duet Team. Published 2026-07-07, updated 2026-07-10. 11 min read.
Every "best MCP servers" list hands you the same two dozen npm commands and moves on. None of them tell you which packages are abandoned, which ones ship with write access you did not ask for, or which official reference servers got archived last quarter and now point to dead installs.
**Most guides hand you a list. This one hands you a list you can defend.**
Every server below is grouped by the job it does, tagged with its transport and auth model, and paired with an install command we verified live before publishing. Where the official package is archived or renamed, we say so and point to the maintained replacement. Start with the vetting checklist, then take the servers you need.
The MCP servers worth adding to Claude Code cover three jobs: reading and writing code (Filesystem, Git, GitHub), querying data (Postgres MCP Pro, SQLite), and grounding answers in current sources (Context7, Brave Search, Fetch). That is eight servers that handle most day-to-day coding work. Before you add any of them, vet it: confirm it is maintained, read what it can touch, and scope its token to the minimum. A server you cannot audit is a server you should not connect.
---
## How to Vet an MCP Server Before You Add It
An MCP server runs code on your machine or holds a token to your accounts. Treat adding one like adding a dependency, because that is exactly what it is. Four checks, every time.
**1. Official or community, and does it matter here?** Anthropic and vendors like GitHub, Sentry, and Notion publish first-party servers. Community servers fill the gaps. Neither is automatically safe. Know which one you are installing so you know who to trust and where to file bugs.
**2. Read what it can touch.** Open the source or the README and find the tool list. A Filesystem server scoped to one directory is low risk. A shell-execution server is not. If the tool list is longer than the job you need, that is surface area you are taking on for no reason.
**3. Scope the token to the minimum.** Most servers that reach a cloud service want an API token. Give it a read-only token when you only need reads. Restrict OAuth scopes to the one or two you actually use. A database server with a read-only connection string cannot drop a table, no matter what the model asks it to do.
**4. Check that it is still alive.** Official reference servers get archived. Community packages get abandoned. Before you trust an install command, confirm the package published recently and the repo is not read-only. Every command in this post was verified live on the publish date for exactly this reason.
---
## Adding a Server: The One Command
You add every server below with `claude mcp add`. The shape changes with the transport.
```bash
# Remote HTTP server (cloud services)
claude mcp add --transport http --header "Authorization: Bearer YOUR_TOKEN"
# Local stdio server (runs as a subprocess on your machine)
claude mcp add --transport stdio -- [args...]
```
All flags (`--transport`, `--env`, `--scope`, `--header`) come before the server name. The `--` separates the name from the command Claude Code runs. Check any server with `/mcp` inside a session, or `claude mcp list` from your shell.
A note on runtimes: Node servers run through `npx -y`, which fetches and runs the package on demand. Python servers run through `uvx`, the [uv](https://docs.astral.sh/uv/) runner, which does the same for PyPI. If a command below uses `uvx`, install uv first.
---
## Code and Repo Servers
The core of any coding workflow. These let Claude Code read your files, work your git history, and manage your GitHub.
### Filesystem
Scoped read and write access to directories you name. The safest way to give the agent file access without handing it your whole disk.
- **Maintainer:** official Anthropic reference server
- **Transport:** stdio · **Auth:** none (access is the directory you pass)
```bash
claude mcp add --transport stdio filesystem \
-- npx -y @modelcontextprotocol/server-filesystem /path/to/project
```
Pass only the directories the task needs. Everything outside them is invisible to the server, which is the point.
### Git
Local git operations as tools: status, diff, log, blame, commit. Lets the agent reason about your history without you narrating it.
- **Maintainer:** official Anthropic reference server (PyPI)
- **Transport:** stdio · **Auth:** none
```bash
claude mcp add --transport stdio git \
-- uvx mcp-server-git --repository /path/to/repo
```
This is separate from GitHub. Git handles your local repository. GitHub handles the remote, the PRs, and the issues.
### GitHub
Pull requests, issues, code search, and reviews against github.com.
- **Maintainer:** official GitHub server. Note: this moved from an npm package to a remote HTTP endpoint. The old `npx` install is dead. Use the URL below.
- **Transport:** HTTP · **Auth:** GitHub personal access token
```bash
claude mcp add --transport http github https://api.githubcopilot.com/mcp/ \
--header "Authorization: Bearer YOUR_GITHUB_PAT"
```
Scope the PAT to the repos you work in. A token with org-wide write access is a liability the moment it leaks into a log.
---
## Database Servers
Let the agent query your data directly instead of you pasting rows into chat. Read-only by default, always.
### Postgres MCP Pro
Query, inspect schemas, and analyze performance against a Postgres instance. The official reference Postgres server was archived, so this maintained community server by crystaldba is the one to use.
- **Maintainer:** community (crystaldba), replaces the archived official server · PyPI package `postgres-mcp`
- **Transport:** stdio · **Auth:** connection string, plus an access mode
```bash
claude mcp add --transport stdio postgres \
--env DATABASE_URI="postgresql://readonly:pass@host:5432/app" \
-- uvx postgres-mcp --access-mode=restricted
```
`--access-mode=restricted` blocks writes and destructive statements. Use it unless you have a specific reason not to, and pair it with a read-only database role so the restriction holds at two layers.
### SQLite
Query a local SQLite database file. The official reference SQLite server was also archived. This npm package is the maintained drop-in.
- **Maintainer:** community, replaces the archived official server · npm package `mcp-server-sqlite-npx`
- **Transport:** stdio · **Auth:** none (path to the database file)
```bash
claude mcp add --transport stdio sqlite \
-- npx -y mcp-server-sqlite-npx /path/to/database.db
```
Good for local development databases, analytics exports, and anything you would otherwise open in a SQLite browser.
---
## Web Grounding Servers
Keep the agent's answers tied to current, real sources instead of stale training data. This is the group that most reduces hallucination in day-to-day coding.
### Context7
Pulls up-to-date, version-specific documentation for thousands of libraries straight into context. Stops the agent from writing against an API that changed two releases ago.
- **Maintainer:** community (Upstash) · npm package `@upstash/context7-mcp`. Note: this is not `@context7/mcp-server`, a name some older guides still print.
- **Transport:** stdio · **Auth:** none for basic use, optional API key for higher rate limits
```bash
claude mcp add --transport stdio context7 \
-- npx -y @upstash/context7-mcp
```
### Brave Search
Web and local search with an independent index. Brave now ships its own official server, which supersedes the archived reference one.
- **Maintainer:** official Brave server · npm package `@brave/brave-search-mcp-server`
- **Transport:** stdio · **Auth:** Brave Search API key
```bash
claude mcp add --transport stdio brave-search \
--env BRAVE_API_KEY=YOUR_KEY \
-- npx -y @brave/brave-search-mcp-server
```
### Fetch
Retrieves a URL and converts the page to clean markdown for the model to read. The simplest way to let the agent read a doc, a changelog, or an RFC you link it to.
- **Maintainer:** official Anthropic reference server (PyPI)
- **Transport:** stdio · **Auth:** none
```bash
claude mcp add --transport stdio fetch \
-- uvx mcp-server-fetch
```
Fetch pulls external content into your session, which is exactly where prompt injection lives. Only point it at sources you trust, and keep the vetting checklist in mind.
---
## Eight Servers, Not Fifty
You do not need a wall of servers. These eight cover the jobs that come up every day: touching code, querying data, and grounding answers in current sources. Each one is maintained, each install command was verified live, and each is scoped to give the agent what the task needs and nothing more.
When you do reach for a comms or notification server later, Slack, Sentry, Notion, run it through the same four checks first. The list you can defend is short on purpose.
---
## Frequently Asked Questions
**Are MCP servers safe to use?**
They are as safe as the vetting you do before adding them. An MCP server runs code or holds a
token, so treat it like any dependency: confirm it is maintained, read what it can touch, and
scope its credentials to the minimum. See the vetting checklist at the top of this post.
**How many MCP servers should I run at once?**
Only the ones a task needs. Claude Code defers tool loading, so idle servers cost little
context, but every connected server is auth surface and one more thing that can break. Add per
project via `--scope project`, not globally.
**What's the difference between the Git and GitHub servers?**
Git handles your local repository: status, diff, log, blame, and commits, with no network
access. GitHub handles the remote side: pull requests, issues, code search, and reviews against
github.com, which is why it needs a personal access token. Most coding workflows use both.
**Why not use the official Postgres and SQLite servers?**
Because they were archived. Anthropic's original reference servers for Postgres and SQLite are
now read-only repos with no maintenance. The install commands in older guides still point at
them. This post uses maintained replacements instead: `postgres-mcp` from crystaldba and
`mcp-server-sqlite-npx`, both verified live on the publish date.
**Do I have to reinstall a server for every project?**
No. Use `--scope` to control where a server is available. `--scope project` writes config to the
project so a server like Postgres only loads where you need it. `--scope user` makes a server
available everywhere, which suits general tools like Fetch or Context7. Scope database and repo
servers to the project, not globally.
**Is an MCP server the same as a Claude Code skill?**
No. An MCP server connects Claude Code to an external system through a running process or
endpoint. A skill is a packaged set of instructions and files the agent loads on demand. They
solve different problems and often work together. See [Skills vs
MCP](/guides/agent-skills-101-tools-vs-mcp-vs-skills) for where each fits.
## Keep reading
- [Claude Code MCP Servers: Complete Setup Guide](/guides/claude-code-mcp-servers-setup). The full setup, scopes, and troubleshooting reference this post builds on.
- [Skills vs MCP: What's the Difference](/guides/agent-skills-101-tools-vs-mcp-vs-skills). Where MCP fits alongside Tools and Skills.
- [Claude Code for Teams](/guides/claude-code-for-teams). Sharing MCP config across a team with project scope.
---
Source: https://duet.so/blog/openclaw-vs-managed-ai-agent-platforms
# OpenClaw Alternatives Compared: Self-Hosted vs Managed AI Agents (2026)
*Not sure if you should self-host OpenClaw or use a managed AI agent platform? Compare costs, security, team features, and setup to find the right approach.*
By David. Published 2026-03-01, updated 2026-05-08. 12 min read.
# OpenClaw vs Managed AI Agent Platforms: Which Is Right for Your Team?
You've been using AI tools for a while now.
Maybe you've outgrown the one-size-fits-all ChatGPT wrapper, or you're trying to give your team access to an agent without everyone having to set up their own environment.
The question you might have is do I self-host something like OpenClaw and own the infrastructure, or do I use a managed platform that just works out of the box?
Both are legitimate paths.
OpenClaw gives technical users full control, every config, every integration, every data point stays on your server.
Managed platforms like Duet trade that control for speed, collaboration, and zero maintenance.
This comparison breaks down exactly when each choice makes sense, what you give up with each, and which one actually fits the way your team works.
Quick Summary
Looking for OpenClaw alternatives? This comparison breaks down self-hosting OpenClaw vs using a managed AI agent platform like Duet, covering security, setup time, team collaboration, and cost.
Questions this page answers
- Best OpenClaw alternatives for teams
- OpenClaw vs managed AI agent platforms
- Should I self-host OpenClaw or use a managed platform?
- OpenClaw vs Duet: which is better for teams?
- Self-hosted vs managed AI agents: what's the difference?
OpenClaw is an open-source AI agent platform you host yourself, offering full control and a 13,000+ skill ecosystem.
Managed platforms are cloud-hosted services with built-in security, multi-user collaboration, and zero maintenance.
Choose OpenClaw for solo technical work where you need complete customization. Choose managed platforms for teams, non-technical users, or when security compliance and 24/7 uptime are requirements.
## What is OpenClaw?
OpenClaw is an open-source AI agent platform with ~140,000 GitHub stars. You download it, run it locally or on your own server, and interact through a messaging-app interface.
Key characteristics:
- Self-hosted: You provide the infrastructure
- Single-user by default: Built for individual workflows
- Open source: Full code access, community contributions
- 13,000+ skills: Community-built integrations and tools
- Free core platform: You pay only for AI model API costs
OpenClaw gives technical users complete control. You can modify source code, add custom integrations, and keep all data on your own infrastructure.
## What are Managed AI Agent Platforms?
Managed platforms are cloud-hosted services that run AI agents for you. They handle infrastructure, security, updates, and multi-user access.
Common features:
- Cloud-hosted: No local setup required
- Multi-user: Built for team collaboration
- Pre-configured integrations: Connect services with OAuth
- Automatic updates: Security patches and feature releases
- Support and SLAs: Enterprise-grade uptime guarantees
Managed platforms trade customization for convenience. You get production-ready infrastructure without DevOps work.
## OpenClaw vs Managed Platforms
## When Should You Choose OpenClaw?
OpenClaw is the right choice in specific scenarios:
You're a solo technical user. If you're comfortable with command-line tools, environment variables, and basic server management, OpenClaw gives you maximum flexibility.
You need full control. Regulations or company policy require all data to stay on your infrastructure. You can run OpenClaw in your own VPC or on-premises.
You value open source. You want to inspect code, contribute to the project, or avoid vendor lock-in with proprietary platforms.
You're building custom integrations. Your workflow requires deeply customized tools that don't exist in pre-built skill libraries.
Cost optimization matters. For solo users, OpenClaw's free core means you only pay for AI API calls and your chosen infrastructure.
### OpenClaw Cost Breakdown
For a solo developer:
- Platform: Free
- AI API: $20-100/month (Anthropic, OpenAI)
- Hosting: $5-50/month (Digital Ocean, AWS)
- Total: $25-150/month
## When Should You Choose a Managed Platform?
Managed platforms make sense for different use cases:
You're working in a team. Multiple people need to collaborate with the same agent, share context, and see each other's work. Built-in multi-user support is table stakes.
You're non-technical. You want AI agents but don't want to manage servers, configure OAuth, or debug networking issues. Click-to-connect integrations matter.
Security and compliance are requirements. You need SOC 2, GDPR compliance, role-based access control, and audit logs out of the box.
You need 24/7 uptime. Your agent handles customer support, monitors production systems, or runs critical workflows. Downtime costs money.
You value time over cost. Setup time, maintenance burden, and troubleshooting have opportunity cost. Paying for managed infrastructure frees your team to build.
### Managed Platform Cost Breakdown
Typical pricing for a team of 5:
- Platform: $50-200/user/month
- AI API: $100-500/month (shared across team)
- Total: $350-1,500/month
## Cost Comparison: Is OpenClaw Actually Cheaper?
For solo users, yes. For teams, it depends.
### Solo User (1 person)
OpenClaw: $25-150/month
Managed Platform: $100-300/month
OpenClaw saves $75-150/month. If you're technical and working alone, the savings add up.
### Small Team (3-5 people)
OpenClaw: $300-800/month (infrastructure + setup labor)
Managed Platform: $350-1,500/month
OpenClaw might look cheaper, but factor in:
- Initial setup: 8-12 hours engineering time
- Monthly maintenance: 2-4 hours/month
- Multi-user configuration: Custom auth, shared state
At $100/hour engineering rate, setup costs $800-1,200. Monthly maintenance adds $200-400. First-month true cost: $1,300-2,600.
Managed platforms break even or win for teams.
### Enterprise (10+ people)
Managed platforms typically win. Enterprise OpenClaw deployments require:
- Dedicated DevOps for maintenance
- Custom SSO integration
- High-availability infrastructure
- Security audits and compliance work
Most enterprises choose managed platforms to avoid this overhead.
## Security: OpenClaw vs Managed Platforms
OpenClaw gives you control but also responsibility. You must:
- Keep dependencies updated
- Configure secure authentication
- Monitor for vulnerabilities
- Implement access controls
Managed platforms handle this by default.
## Team Collaboration: Where OpenClaw Falls Short
OpenClaw was built for single-user workflows. Teams hit limitations:
No built-in multi-user access. Multiple people can't interact with the same agent instance simultaneously without custom engineering.
No permission controls. Everyone who accesses your OpenClaw instance has full access to all conversations, integrations, and data.
No shared context. When one teammate adds an integration or trains the agent, others don't automatically benefit.
No audit trail. You can't see who asked the agent to do what, when, or why.
These aren't OpenClaw design flaws. The project optimizes for individual power users, not team collaboration.
## Persistence and Uptime
OpenClaw: Runs on your laptop or server. If your machine sleeps or loses internet, the agent stops. You're responsible for uptime.
Managed platforms: Cloud-hosted with redundancy. The agent stays online 24/7, continues long-running tasks, and handles scheduled jobs even when you're offline.
For background tasks like monitoring GitHub, processing emails, or running scheduled reports, managed platforms have a structural advantage.
## Skill Ecosystem: Quality vs Quantity
OpenClaw: 13,000+ community-contributed skills. Massive selection, variable quality. You can install any skill or build your own.
Managed platforms: 100-10,000+ pre-built integrations. Fewer options, but each one is tested, documented, and maintained by the platform.
Trade-off: OpenClaw gives you more choice. Managed platforms give you more reliability.
## Maintenance Burden
### OpenClaw Monthly Maintenance
- Update dependencies (npm, pip, system packages)
- Apply security patches
- Monitor resource usage (CPU, memory, disk)
- Backup conversation history and configurations
- Troubleshoot integration breakages when APIs change
Estimate: 2-4 hours/month for a solo user, 10-20 hours/month for team deployments.
### Managed Platform Monthly Maintenance
- None. Provider handles updates, scaling, and monitoring.
If your time is worth $100/hour, OpenClaw's "free" platform costs $200-2,000/month in labor.
## Real-World Use Cases
### Use Case 1: Solo Founder Building an MVP
Scenario: Technical founder, building a SaaS product, needs AI help with code, research, and operations.
Best Choice: OpenClaw
Why: Solo user, technical, cost-sensitive, needs deep customization. OpenClaw's 13,000 skills and full code access enable rapid experimentation.
### Use Case 2: 8-Person Engineering Team
Scenario: Team needs shared AI assistant for code reviews, documentation, oncall support, and sprint planning.
Best Choice: Managed platform
Why: Multi-user collaboration, always-on availability, team members have varying technical skill. Managed platform's built-in access controls and 24/7 uptime are critical.
### Use Case 3: Enterprise with Compliance Requirements
Scenario: Financial services company, needs AI agents but must meet SOC 2, GDPR, and data residency requirements.
Best Choice: Managed platform (enterprise tier) or private OpenClaw deployment
Why: If a managed platform offers data residency and compliance certifications, it's faster to deploy. Otherwise, private OpenClaw with dedicated security engineering.
### Use Case 4: Open Source Contributor
Scenario: Developer who wants to build custom skills and contribute to the agent ecosystem.
Best Choice: OpenClaw
Why: Full source code access enables contribution. OpenClaw's open-source nature aligns with contributor values.
## Duet: OpenClaw for Teams
If you like OpenClaw's power but need team collaboration, consider Duet.
Duet runs in the cloud like a managed platform but maintains OpenClaw's extensibility. Multiple team members work with the same AI coworker through durable sessions, shared files, and workspace roles. The agent stays online, handles long-running tasks, and keeps its work history available to the team.
Key differences from OpenClaw:
- Multi-user by default: Shared sessions, files, apps, and workspace roles
- Persistent sessions: Agent runs on cloud infrastructure, never sleeps
- Zero setup: No local installation or server management
- Built-in integrations: 10,000+ apps through managed connectors
Key differences from typical managed platforms:
- Reusable context: Instructions in Files and durable facts and sources in Train
- Open architecture: Build sandbox apps, deploy tools, extend functionality
- AI-native: Built from the ground up for AI agent workflows
Learn more at duet.so.
## How to Choose: Decision Framework
Ask yourself these questions:
### Are you working solo or in a team?
- Solo: OpenClaw becomes viable
- Team (3+ people): Managed platform saves time
### Are you technical or non-technical?
- Technical: OpenClaw's setup is manageable
- Non-technical: Managed platform removes complexity
### Do you need 24/7 uptime?
- Yes: Managed platform (or cloud-hosted OpenClaw with monitoring)
- No: Local OpenClaw works
### What's your monthly budget?
- Under $200/month: OpenClaw wins for solo users
- Over $500/month: Managed platform's labor savings matter
### Do you need compliance certifications?
- Yes: Managed platform (unless you have security team)
- No: Either option works
### How important is time-to-value?
- Critical (need it today): Managed platform (2-minute signup)
- Flexible (can spend a weekend): OpenClaw (30-60 minute setup)
## Migration: Can You Switch Later?
OpenClaw to managed platform: Relatively easy. Export conversation history, reconnect integrations via OAuth.
Managed platform to OpenClaw: Harder. Most platforms don't export custom configurations or agent training. You'll rebuild integrations.
Between managed platforms: Varies. Some offer import tools, others require manual migration.
Start with the option that matches your current needs. Switching is possible but costs time.
## FAQ
### Is OpenClaw safe to use?
Yes, if you maintain it properly. OpenClaw is open source, so security researchers can audit the code. However, you're responsible for:
- Keeping dependencies updated
- Securing your hosting environment
- Protecting API keys and credentials
- Configuring authentication
Managed platforms handle these tasks for you.
### Can OpenClaw work for teams?
Technically yes, but it requires engineering work. OpenClaw is designed for single users. Multi-user setups need:
- Custom authentication system
- Shared state management
- Access control and permissions
- Centralized hosting
Most teams find managed platforms easier.
### How does OpenClaw compare to Duet?
OpenClaw is self-hosted and single-user. Duet is cloud-hosted and multi-user.
Choose OpenClaw if you're a solo technical user who wants full control. Choose Duet if you're working in a team and need collaboration features, 24/7 uptime, and zero maintenance.
### What's the best AI agent platform for business?
Depends on business size and needs:
- Solo technical founder: OpenClaw (cost-effective, flexible)
- Small team (3-10 people): Managed platform like Duet (collaboration, reliability)
- Enterprise (50+ people): Enterprise-tier managed platform (compliance, support, SSO)
### Can I run OpenClaw in the cloud for 24/7 uptime?
Yes. Deploy OpenClaw to a cloud VM (AWS, Digital Ocean, Azure) and keep it running.
You'll need:
- Server provisioning and configuration
- Process management (systemd, Docker)
- SSL certificates for secure access
- Monitoring and alerting
This setup costs $20-100/month in infrastructure plus engineering time.
For a detailed guide, see How to Host OpenClaw in the Cloud.
### Do managed platforms support custom integrations?
Most do, through APIs or plugin systems. Check documentation for:
- MCP server support (Model Context Protocol)
- Custom skill APIs
- Webhook integrations
- CLI or SDK for automation
Managed platforms balance ease-of-use with extensibility.
### Is OpenClaw better than Claude Code?
Different tools for different jobs. Claude Code is an AI coding assistant built into your terminal. OpenClaw is a general-purpose AI agent platform.
Use Claude Code for software development. Use OpenClaw (or a managed platform) for operations, research, and cross-tool automation.
For a detailed comparison, see Claude Code vs Cursor vs Codex.
## Recommendation For You
Choose OpenClaw if:
- You're a solo technical user
- You need full control and customization
- Cost is your primary constraint
- You value open source and community
Choose a managed platform if:
- You're working in a team (3+ people)
- You need 24/7 uptime and reliability
- Security compliance is required
- You want to focus on work, not infrastructure
Both are legitimate choices. OpenClaw is powerful for individual power users. Managed platforms are built for teams and production reliability.
Match the tool to your situation. A solo founder on a $1,000/month runway has different needs than a 20-person engineering team at a Series A startup.
Choose based on your current reality, not aspirations. You can always switch later.
---
Source: https://duet.so/blog/package-your-expertise-into-an-ai-agent
# Package Your Expertise Into an AI Agent You Can Sell
*Learn how to sell AI agents built from your own expertise — no code required. A concrete, step-by-step guide to package, price, and run one.*
By Duet Team. Published 2026-07-03. 14 min read.
A productized service turns your expertise into a repeatable offer: instead of selling your hours, you package what you know into a fixed, priced-in-advance thing clients buy — increasingly, an AI agent trained on your judgment. This guide walks through identifying what to package, training an agent on it, pricing it, and keeping it accurate after launch.
**Package Your Expertise Into an AI Agent**
Packaging your expertise into a sellable AI agent means identifying the repeatable 20% of your work, training an agent on your existing documents and call transcripts, pricing access to it (not the technology), selling the outcome to your first client, and keeping its knowledge current after launch.
## What is a productized service?
A productized service is a fixed, scoped offer with a set price — the opposite of open-ended hourly consulting. It answers "what do I get and what does it cost" before the client ever talks to you.
Productizing isn't the same as making your work cheaper — that's commoditization. It means isolating the highest-leverage, most repeatable 20% of what you do and turning that slice into something a client can buy without negotiating your calendar.
An AI agent is one delivery mechanism for a productized service, arguably the best one: it's the only format giving a client real-time, interactive access to your judgment instead of a static document. A course teaches once. Coaching happens on your schedule. An agent answers the client's question the moment they have it, even at 2am on a Saturday.
## Why turn your expertise into an AI agent instead of a course or a coaching program?
Courses and coaching both cap out on real-time access. An agent doesn't.
Courses are static — most buyers never finish, because no one answers the question that comes up on module 3. Coaching caps at your hours: you can only take so many calls a week, and clients wait for the next session to get unstuck.
An AI agent trained on your expertise gives clients continuous, personalized access to your judgment between engagements. It doesn't replace you — it scales the repeatable 80% of what you do (the questions you've answered a hundred times) so you're freed up for the judgment-heavy 20% that never productizes well: the strategy call, the edge case, the relationship work only you can do.
## What do you need to identify before you package anything?
The bottleneck isn't tooling. It's figuring out which slice of your own expertise is actually repeatable, and most experts have never had to name it before.
**The 80/20 identification exercise.** Review your last 20 client projects. Ask:
1. What problem came up over and over, almost word-for-word?
2. What have you explained the same way more than 10 times?
3. What only lives in your head, or in old call recordings, that a new hire would need six months to learn?
Consultant Mike Gammarino ran this exercise on his own client base and [noticed that more than 90% of his prospects had the same core problem](https://www.consultingsuccess.com/consultants-guide-to-productization) — a broken sales funnel. He built a fixed-scope $2,500 Sales Funnel Audit around that one recurring problem instead of selling open-ended hours.
**The Client / Problem / Process framework.** Narrow to one client type, one recurring problem that type has, and one systematic process you already use to solve it. Jane Portman, founder of [UI Breakfast](https://www.consultingsuccess.com/consultants-guide-to-productization), used this to split a generic "UX consulting" offer into three fixed-scope products: a UX Audit, a Conversion Optimization package, and a Design System Creation package.
Service business owners can run the same exercise on whatever their team repeats most (see [how service business owners use AI to scope this work](/use-cases/small-businesses/service-business-owner)); agencies face a similar packaging problem with client deliverables (see [how agencies package client work](/use-cases/agencies)).
## What files actually work for training an AI agent on your expertise?
Almost anything you already have works — docs, PDFs, slide decks, spreadsheets, call transcripts, and links can all train an agent together. There's no single required file type.
What matters more is structure. [AWS's guidance on preparing content for retrieval-augmented systems](https://docs.aws.amazon.com/prescriptive-guidance/latest/writing-best-practices-rag/best-practices.html) recommends clear headings, flat lists over dense tables, one idea per section, and jargon defined inline.
A reasonable starting folder looks like this:
| File | Why it helps |
| -------------------------------------------- | --------------------------------------------------------------- |
| Case notes / past project write-ups | Captures your actual decision-making, not just your conclusions |
| Call transcripts | Shows how you explain things live, in your own words |
| Pricing or scoping frameworks (slides, docs) | Teaches the agent your boundaries, not just your knowledge |
| Client FAQ documents | Pre-answers the questions clients ask most |
| Process checklists | Encodes the repeatable steps directly |
| Reference links | Lets the agent point to source material instead of guessing |
You don't need a polished manual first. Messy is fine — this is exactly the input the next section covers.
## How do you actually train an agent on what you know?
You don't build an agent by configuring a flow — you train it by pointing it at what you already have. That's the practical difference between a [no-code AI agent builder](/blog/6-best-ai-agent-builders-in-2026) and a training-based approach.
A no-code AI agent builder has you configure logic, nodes, and branches from scratch — a different skill than knowing your own business, and exactly where most non-technical experts get stuck. Training skips that step: you hand the agent your existing material and it does the synthesis work.
This is where Duet's `train` feature does the actual work. Instead of dragging nodes around a
flow-builder, you point Duet at a folder — your case notes, PDFs, slide decks, spreadsheets,
call transcripts, even old email threads — and it reads all of it, recursively, no matter the
format. It doesn't summarize; it synthesizes exhaustively, the way a sharp analyst would read
your entire body of work and write one dense, complete briefing rather than a highlight reel
that quietly drops the third item in a list or the exception buried in paragraph four.
That briefing becomes the agent's durable, top-priority memory — the first thing it reaches for
on every client conversation, and it never silently expires or gets pruned. When your
methodology changes, you re-train the same way: point `train` at the updated folder, and Duet
replaces the old understanding with the new one, with no gap where the agent knows nothing.
[Set up Duet in about 10 minutes](/guides/how-to-set-up-duet) and try it on your own files.
Treat the agent like you're briefing a sharp new hire: what its role is, what it should always do, what it should never claim, and what to say when it doesn't know something. That framing keeps it useful instead of confidently wrong.
Still comparing tools first? [This comparison of AI agent builders](/blog/6-best-ai-agent-builders-in-2026) covers where flow-builders fit and where they fall short for this exact use case.
## How much should you charge clients for access to your agent?
Price the outcome the client gets, not the technology behind it. Never lead with "AI-powered" — lead with the specific judgment or access the client is paying for.
Consultant and author Chris Lema frames pricing around three moves — [Packaging, Pricing, and Progressions](https://chrislema.com/how-do-you-productize-consulting-services):
- **Packaging** is defined by what's excluded. A tight, bounded scope makes a fixed price possible.
- **Pricing** builds in margin from day one — never average your past hourly engagements into a subscription number.
- **Progressions** sequence your offers instead of selling one monolithic product: cheap diagnostic first, then implementation, then ongoing access.
That progression model doubles as a sales ladder for an agent specifically: a free or low-cost diagnostic agent gets someone in the door, a paid ongoing-access agent is the core product, and a human engagement sits above both for anything the agent can't handle.
A few concrete pricing shapes to anchor on:
| Model | How it works | Best for |
| ------------------- | ------------------------------------------------------------------ | ---------------------------------------------- |
| Flat subscription | Fixed monthly fee for standalone agent access | Clients who want ongoing, self-serve access |
| One-time diagnostic | Lower-friction entry price for a bounded assessment | New clients not ready to commit |
| Bundled add-on | Folded into an existing high-ticket engagement | Existing clients, upsell motion |
| Membership | Recurring fee for ongoing access plus community/expert touchpoints | Larger audiences, lower individual price point |
[MeasureU Pro](https://measureu.com/pro/) shows the membership shape clearly: $1,997/year for ongoing access plus 18 expert mentors via live sessions — not an AI agent specifically, but a fixed annual fee for ongoing access to expertise, not a per-hour rate.
## How do you actually sell it to your first client?
Sell the outcome, not the capability. "An agent that gives your team 24/7 access to my pricing judgment" sells. "An AI chatbot trained on my content" doesn't — most buyers are still confused about what an AI agent actually is, and vague language makes that worse.
Jeff Sauer, who sold an 8-figure marketing agency and now runs a 6-person team on AI agents through [MeasureU](https://measureu.com/sell-ai-agents/), says to sell agents like any other outcome: name the specific problem and the specific result, and let pricing follow rather than lead. His pitch borrows a line — "AI agents are like teenage sex" — everyone's talking about it, few have done it, fewer know if they're doing it right. That line traces to analytics writer Avinash Kaushik, not Sauer, but it names the real client-education gap.
Sauer's close is a menu, not a defense: present two tiers so the client picks between options instead of deciding yes/no on one price. Then ask two questions — what result would make this worth it, and what's stopping you from starting today.
If your pipeline is thin, [here's how to find prospects for a new freelance offer](/blog/how-to-use-ai-to-find-prospects-for-freelance-business) before you pitch anyone.
## Who keeps the agent accurate after you launch it?
You do, on an ongoing basis — "train once and walk away" is a real risk, not a caveat. An agent's knowledge goes stale silently: it states outdated information as confidently as current information, with no warning to the client.
[Atlan notes that stale embeddings can degrade retrieval accuracy by up to 20%, with no uncertainty signal to warn users](https://atlan.com/know/llm-knowledge-base-staleness/) once a knowledge base drifts out of date. [Slite puts the human cost plainly](https://slite.com/learn/self-maintaining-knowledge-base-guide): "One stale doc no longer mis-trains one human. It mis-trains every downstream bot, and unlike a human, the bot won't know to ask in Slack."
That's the gap most agent-selling advice skips — plenty covers packaging and selling, almost none covers what happens six months in when your process has changed and the agent hasn't. The fix: treat the agent's knowledge as a living asset with an owner, updated the day your methodology changes.
In Duet, re-training is repeatable, not a rebuild — point `train` at your updated folder and the old understanding is replaced cleanly, with no window where the agent knows nothing. More in [why AI agents forget (and how to stop it)](/guides/ai-amnesia-why-your-ai-keeps-forgetting).
## What's the full loop — package, sell, run — and why does skipping the third step break the model?
The complete model has three steps, not two: package your expertise, sell access to it, and keep running it. Most advice stops after step two.
Package is the identification and training work above. Sell is pricing and pitching your first client. Run is the part almost nobody talks about — keeping the agent's knowledge current and re-training when your methodology moves.
Skip Run and the other two steps quietly decay. A packaged offer that goes stale stops being sellable, and an agent that's confidently wrong damages the trust that got you the sale. The loop only works as a loop — Package feeds Sell, Sell generates the usage that tells you what to update, and Run feeds that back into Package.
[Build an agent that runs continuously](/blog/how-to-set-up-a-24-7-ai-agent) rather than one you train once and hope holds up. If you're ready to try the loop on your own expertise, [see Duet's pricing](/pricing) and start with what's already sitting in a folder somewhere.
## Frequently Asked Questions
### Do I need to know how to code to package my expertise into an AI agent?
No. Training an agent means dropping in documents, PDFs, and call transcripts you already have — no flow-building or prompt engineering required.
### What's the difference between a productized service and just selling an AI agent?
A productized service is the umbrella: a fixed, priced-in-advance offer instead of hourly work. An AI agent is one way to deliver it — arguably the most scalable, since it gives clients real-time access to your judgment instead of a static course.
### How is training an agent different from using a no-code AI agent builder?
A no-code builder has you configure flows and logic from scratch. Training means pointing the agent at what you already have and letting it synthesize your expertise directly — no flow-building involved.
### How much should I charge for access to my AI agent?
Price the outcome, not the technology. Common patterns: a flat monthly subscription, a lower-priced one-time diagnostic, or bundling access into an existing higher-ticket engagement. Build in margin; don't average past hourly rates.
### What happens if my expertise or methodology changes after I launch the agent?
You re-train it. Left unmanaged, an agent's knowledge goes stale silently, stating outdated advice as confidently as current advice. Treat its knowledge as a living asset with an owner, not a one-time export.
### Will the AI agent replace me as the expert?
No — it scales the repeatable 80% of what you do so you're freed for the judgment-heavy 20% that never productizes well: strategy calls, edge cases, relationship work.
### What file types can I use to train an agent on my expertise?
Docs, PDFs, slides, spreadsheets, call transcripts, and links all work together. What matters more than file type is structure: clear headings, one idea per section, jargon defined inline.
---
Source: https://duet.so/blog/slack-alternatives-with-ai-agents-2026
# Slack Alternatives in 2026: Honest Comparison
*Slack and Teams compared with Duet and other AI workspaces in 2026: human coordination, persistent agents, app hosting, and private cloud workspaces.*
By Duet Team. Published 2026-05-21. 16 min read.
For 10 years, team chat meant Slack or Microsoft Teams. The AI layer was a thin add-on: a /chatgpt slash command, a sidebar summarizer, a Claude bot in a channel.
In 2026, a second question emerged: should AI remain a bot inside the messenger, or should it own a separate durable work environment?
There are two architectures now. In one, the AI is a participant in a message thread. It can answer questions, summarize, draft messages, and sometimes call tools. In the other, the AI has a private cloud server, durable sessions, a filesystem, scheduling, memory, integrations, and hosted apps. Slack can remain the human coordination layer while the AI workspace owns execution.
That distinction matters more than any feature table. And it's the lens this comparison is built on.
We make Duet, so we'll tell you where it wins and where it loses to Slack today.
Let's get into it without any further ado:
## Why Teams Are Looking for Slack Alternatives in 2026
Slack changed how teams communicate. But after a decade, the cracks are showing, especially now that AI is reshaping what a workspace should do:
- Pricing scales per user and gets expensive fast. A 10-person team on Slack Business+ pays $150+/month
- AI features are now bundled into higher tiers, not available as a cheap add-on. To get advanced AI, you need Business+ at $15/user/month. Free and Pro plans only get basic AI
- Bots are chat participants, not workers. They answer questions inside threads but don't have their own computer. No filesystem, no cron, no hosting
- The integration marketplace is deep but the AI layer is shallow. 2,600 apps for notifications and triggers, but the AI can't act on them autonomously
- Compliance is strong, but you're paying enterprise pricing for it. SOC 2 and HIPAA live behind the Business+ and Enterprise Grid tiers
If your team just needs chat, Slack still works. But if you want AI that actually runs work, the alternatives have caught up, and in some cases, passed it.
Here are the 6 best Slack alternatives in 2026, compared honestly.
1. Slack
2. Duet
3. Microsoft Teams
4. Pumble
5. Mattermost
6. Viktor
## Comparison Table For Slack Alternatives
| Tool | Type | AI Built-in | Self-hosting | Free Plan | Starting Price | Best For |
| --------------- | ------------------- | ---------------------- | ------------ | -------------------- | ------------------------------------- | -------------------------------- |
| Slack | Chat + AI add-on | Yes (bundled in tiers) | No | Yes (90-day history) | $7.25/user/mo | Teams with existing integrations |
| Duet | AI-native workspace | Yes (core) | No | Yes | Workspace pricing | Teams that want AI doing work |
| Microsoft Teams | Chat + Copilot | Yes (Copilot add-on) | No | Yes (limited) | $4/user/mo (Copilot from $18/user/mo) | Microsoft 365 orgs |
| Pumble | Traditional chat | No | No | Yes (unlimited) | $2.49/user/mo | Budget-conscious teams |
| Mattermost | Self-hosted chat | Enterprise only | Yes | Yes (self-hosted) | $10/user/mo (cloud) | Compliance-first orgs |
| Viktor | AI agent (plugin) | Yes (core) | No | Yes ($100 credits) | $50/mo (credits) | AI agent inside Slack/Teams |
## Slack
[Slack](https://slack.com/intl/en-in/) is still the default for team communication. Ten years of polish, 2,600+ app integrations, and a workflow system that entire companies run on.
In 2025, Slack bundled AI features directly into its plans: channel summaries, thread recaps, AI-powered search, and a growing bot ecosystem with Claude and ChatGPT. The chat experience is best-in-class. The AI is a helpful layer, not a core architecture.
### Pros
- The deepest integration marketplace in the category. 2,600+ apps with first-party support from nearly every SaaS vendor
- Mature UX with a decade of conventions. Threads, emoji reactions as workflows, channel naming patterns, granular notification controls. New hires already know how to use it
- AI now bundled into plans. Basic AI (summaries, search) included in Free and Pro. Advanced AI (workflow automation, full-history search) in Business+ and Enterprise
- Strong bot ecosystem. Claude, ChatGPT, and custom bots via Slack's API can answer questions and call external tools via MCP or OAuth
- Enterprise-grade compliance: SOC 2 Type 2, HIPAA, FedRAMP, ISO 27001, data residency
### Cons
- AI bots are participants in chat, not autonomous workers. They can't run scheduled jobs, host apps, build dashboards, or maintain memory across conversations
- Advanced AI features require Business+ ($15/user/month) or higher. Free and Pro only get basic summaries
- Bots reset between conversations unless wired through external memory APIs. No persistent context
- The AI can answer and draft, but can't do work. No filesystem, no cron, no code execution, no app hosting
### Pricing
Free plan with limited history. Pro at $7.25/user/month (annual) or $8.75/month (monthly). Business+ at $15/user/month (annual) with advanced AI bundled in. Enterprise Grid at custom pricing. For a 10-person team: $72-$150/month depending on plan and billing.
### Best for
Teams where human coordination is the primary job and AI is a helpful side feature. If your stack is already wired into Slack's marketplace and you need rock-solid compliance, Slack is still the right answer.
## Duet
[Duet](/) is not another team messenger. It is a persistent AI coworker with its own computer. Every workspace gets a dedicated cloud VM, durable sessions, persistent files, trained memory, integrations, and app hosting on custom domains.
The difference shows up in what happens after the conversation ends. Ask Duet to monitor a competitor's pricing page every Monday, and it actually does it, week after week, without being re-prompted. Ask it to build a client portal, and it hosts it on your domain. Ask it to draft your weekly investor update from git history, and next Tuesday it does it again automatically.
### Pros
- Private cloud sandbox per workspace. Your files, cron jobs, and hosted apps live in your team's isolated environment, not shared multi-tenant infrastructure
- Persistent memory across sessions. Duet remembers your ICP, your brand voice, your customer list, research from months ago. No re-prompting
- App hosting on custom domains. The agent builds it, ships it, and keeps running it
- Model-backed sessions with one durable event history and usage attribution
- Scheduled work via cron. The agent runs jobs while you sleep: reports, audits, monitoring, data pulls
- Train stable business context once and reuse it across later sessions
### Cons
- Younger product. The integration catalog is broad, but Duet is not a replacement for Slack's human-communication ecosystem
- Async-first by design. No voice huddles or video calls. Most teams keep a separate tool for real-time communication
- Responsive web access is available, but Duet does not ship native iOS or Android apps in this release
- Learning curve. Working with an AI teammate is a different mental model than working with a chat bot
### Pricing
Workspace-based monthly plans with included credits, not per-seat. The paid reserve covers overage, and a 7-day free trial is available to start.
### Best for
Founders, small teams, and agencies who want AI that does work, not just answers. If your bottleneck is running operations, shipping content, or automating recurring tasks, this is the shape you want.
**[Try Duet free at https://duet.so/](/)**
## Microsoft Teams
[Microsoft Teams](https://www.microsoft.com/en-in/microsoft-teams/group-chat-software) is the default Slack alternative for any organization already paying for Microsoft 365. It bundles chat, video calls, file storage, and now Microsoft Copilot into a single workspace. If your company runs on Outlook, SharePoint, and OneDrive, Teams is the path of least resistance.
### Pros
- Included free with Microsoft 365 business plans, so most companies already have it
- Deepest video conferencing in the category (meetings, webinars, town halls, live events)
- Microsoft Copilot can summarize meetings, draft messages, and pull context from your Microsoft graph
- Enterprise compliance: SOC 2, HIPAA, FedRAMP, ISO 27001, data residency controls
### Cons
- AI capabilities require a separate Copilot license. Business tier is $18/user/month (rising to $21 after June 2026). Enterprise is $30/user/month
- Copilot is limited to the Microsoft ecosystem. It can't run scheduled jobs, build apps, or maintain memory across conversations
- The interface is notoriously cluttered. Channels, tabs, and team structures overwhelm new users
- If your stack isn't Microsoft-heavy, the tight ecosystem lock-in works against you
### Pricing
Included with Microsoft 365 Business Basic ($6/user/month). Copilot Business add-on is $18/user/month (promotional, rising to $21 after June 2026). Copilot Enterprise is $30/user/month. For a 10-person team: $60-$510/month depending on the plan and Copilot tier.
### Best for
Teams already embedded in the Microsoft ecosystem who want AI as a side feature, not a core workflow driver.
## Pumble
[Pumble](https://pumble.com/) is what Slack would look like if it stayed free. Unlimited message history, unlimited users, unlimited channels, all on the free plan. No 90-day archive wall, no "upgrade to search older messages" prompts. For teams that just need a clean chat tool without the AI overhead, Pumble delivers.
### Pros
- Unlimited message history on the free plan (Slack caps at 90 days)
- Unlimited users and channels, even on free tier
- Clean, familiar interface that requires almost no onboarding
- Part of the CAKE.com productivity suite (Clockify, Plaky) for teams already in that ecosystem
### Cons
- No AI features at all. No summarization, no search intelligence, no automation beyond basic workflows
- Integrations are limited compared to Slack's 2,600+ app directory
- Video calls cap at 50 participants on free plan
- No open-source option for self-hosting
### Pricing
- Free: Unlimited users, channels, and message history
- Pro: $2.49/user/month (annual) / $2.99/user/month (monthly)
- Business: $3.99/user/month
- Enterprise: $7.99/user/month
### Best for
Budget-conscious teams that want unlimited messaging without paying per user. Startups, nonprofits, and education teams that just need reliable chat.
## Mattermost
[Mattermost](https://mattermost.com/) is the self-hosted Slack alternative for teams that take data sovereignty seriously. Open source, SOC 2 Type II certified, HIPAA-ready, and deployable on your own infrastructure. If your security team has opinions about where chat data lives, Mattermost is probably already on their shortlist.
The platform goes beyond chat with integrated playbooks (incident response workflows), boards (kanban-style project tracking), and a plugin marketplace. It is a collaboration platform that happens to have messaging, not a messaging app trying to bolt on collaboration.
### Pros
- Full self-hosting option with complete data control
- Open source (MIT license) with active community and plugin ecosystem
- Built-in playbooks for incident response and DevOps workflows
- SOC 2 Type II, HIPAA, and GDPR compliance ready out of the box
- Deep integrations with developer tools (Jira, GitHub, GitLab, Jenkins, PagerDuty)
### Cons
- Self-hosting requires DevOps resources to maintain, patch, and scale
- UI feels functional rather than polished compared to Slack
- AI features (Copilot) only available on Enterprise tier
- Smaller integration marketplace than Slack or Teams
### Pricing
- Free: Self-hosted, unlimited users and message history
- Professional: $10/user/month (cloud-hosted)
- Enterprise: Custom pricing (self-hosted or cloud, with advanced compliance and AI Copilot)
### Best for
Engineering teams, defense contractors, healthcare orgs, and any company where compliance officers have veto power over tool choices. If you need air-gapped deployment or on-premise hosting, Mattermost is the only serious option on this list.
## Viktor
[Viktor](https://viktor.com) is not a Slack replacement. It is an AI coworker that lives inside your existing Slack or Microsoft Teams workspace. It is like adding a team member who happens to be an AI agent with its own cloud computer, persistent workspace, and the ability to actually execute tasks, not just summarize them.
What makes Viktor different from Slack's built-in AI or a ChatGPT wrapper is scope. Viktor can browse the web, write and run code, deploy web applications, maintain a persistent file system across conversations, run scheduled tasks on a cron, and connect to 3,200+ apps through built-in integrations. It remembers context across sessions and can pick up where it left off.
### Pros
- Own cloud computer with persistent workspace that survives between sessions
- Can deploy web apps, run scheduled tasks, and maintain long-running processes
- 3,200+ integrations out of the box (vs Slack AI's read-only access to your workspace)
- Persistent memory across conversations, builds context over time
- Works inside Slack or Teams, no migration needed
### Cons
- Credit-based pricing can be unpredictable for heavy usage
- Adds AI capability to existing platforms rather than replacing them, so you still need Slack or Teams
- Learning curve to understand what the agent can and cannot do autonomously
- Relatively new, smaller community compared to established tools
### Pricing
- Free: Starter plan with $100 in credits to try
- Paid: Credit-based plans starting at $50/month
- Enterprise: Custom pricing for teams
### Best for
Teams that want AI agent capabilities inside their existing Slack or Teams workspace without switching platforms. Power users, ops teams, and developers who need an AI that can actually execute tasks, not just answer questions.
## Honest Decision Framework
Skip the feature war. You just need to answer four questions.
1. **Does your team already live in Slack or Teams and you don't want to migrate?** Add Claude or ChatGPT as a bot. Don't change tools.
2. **Do you want AI inside the SaaS you already pay for?** Anthropic's Claude for Small Business is the cleanest version of that pattern.
3. **Do you want one named AI teammate that ships work between meetings, research, scheduled jobs, dashboards, and follow-ups in the workspace where your team operates?** [Duet](/).
4. **Are you a regulated industry that needs SOC 2 / HIPAA / FedRAMP today?** Stay on Slack Enterprise Grid for now, watch the AI-native category close the gap over 2026-2027.
There is no single best Slack alternative. There is a best one for what you want AI to do.
## How Teams Are Actually Using Duet
A few concrete patterns we see from real Duet workspaces, from our [content team](/blog/how-we-grew-google-traffic-800-percent-with-ai) and [customer use cases](/use-cases):
- **3-person startups** run ops out of Duet: weekly investor updates drafted from git history, customer research scheduled nightly, a hire-tracking dashboard the agent built and now maintains.
- **Agencies** give each client their own Duet workspace: brand-locked content generation, scheduled SEO audits, a private client portal hosted on a custom domain.
- **Operations leads** use Duet as the "team computer", the agent owns the spreadsheets, the data pipelines, the recurring reports. Humans review.
None of these workflows are possible in Slack + bot. Not because Slack is bad, but because the bot doesn't have a computer.
## Our Verdict
If you want AI that does work (not just answers), the strongest AI-native option in 2026 is Duet, which gives every team a private cloud workspace with a persistent AI coworker, app hosting, and cron. Microsoft Teams with Copilot is the strongest answer for teams already on Microsoft 365. Slack + Claude or ChatGPT remains the safest choice if your team doesn't want to migrate off Slack.
Slack with AI bots is good enough if AI's job is to answer questions, summarize threads, and draft messages. It stops being good enough when you want the AI to own a workflow end-to-end: research, build, schedule, maintain.
That's the line. If your team is on one side, stay on Slack. If you've crossed it, try [Duet](/).
## Frequently Asked Questions
### What's the best Slack alternative with AI agents in 2026?
It depends on what you need. Duet is the strongest option if you want an AI agent that can execute tasks autonomously (research, code, schedule, deploy). Microsoft Teams with Copilot is best for Microsoft 365 teams. Slack itself with Claude or ChatGPT bots remains solid if you just need AI answering questions in threads.
### Is Slack good enough with AI bots?
Slack with AI bots is good enough if AI's job is to answer questions, summarize threads, and draft messages. It stops being good enough when you want the AI to own a workflow end-to-end: research, build, schedule, maintain. Bots in Slack can call connected APIs via OAuth or MCP, so they can perform discrete actions (create a Linear ticket, fetch a CRM record). They cannot run persistent processes, host apps, or maintain their own filesystem.
### What makes Duet different from adding ChatGPT to Slack?
Duet gives every workspace a dedicated cloud VM with persistent Files, durable Sessions, Train context, managed Integrations, hosted Apps, and multi-model routing. ChatGPT in Slack is a conversational bot inside the messaging layer. The difference is whether AI only answers there or owns work in a persistent workspace.
### Can Duet replace Slack completely?
Not a direct replacement. Duet's strength is AI-native work execution, not replicating Slack's full human coordination feature set (voice calls, 2,600+ integrations, enterprise compliance certifications). Most teams run both: Slack for human coordination, Duet for AI work.
### How does Viktor compare to Duet?
Viktor is an AI agent that lives inside your existing Slack or Teams workspace, with its own cloud computer, persistent memory, and 3,200+ integrations. Duet is a standalone workspace where durable sessions, files, apps, integrations, and AI execution live together. Viktor augments your current messenger; Duet owns the work environment.
### What's the cheapest Slack alternative for small teams?
Pumble is free with no user limits. Mattermost is free for self-hosting. Slack Pro is $7.25/user/month (annual). For AI-native options, Duet's workspace pricing often works out cheaper than Slack + per-user AI bot subscriptions for teams that use AI heavily.
### Can I use Slack and Duet together?
Yes, most teams do. Slack keeps doing what it's good at (human coordination, voice, 2,600 integrations). Duet runs the AI work and posts results back. They are complementary, not competing.
## Related Reading
- [Duet vs Claude for Small Business: Which AI Runs Your Workflows in 2026?](/blog/duet-vs-claude-for-small-business) — Companion comparison for the Anthropic-bolted-into-SaaS pattern.
- [How to Set Up a 24/7 AI Agent](/blog/how-to-set-up-a-24-7-ai-agent) — The persistent-loop pattern AI-native workspaces are built around.
- [How to Run a Startup's Operations With a 3-Person Team](/blog/how-to-use-ai-to-run-startup-operations-with-a-3-person-team) — Concrete startup-ops workflow on a small team.
- [How We Grew Google Traffic 800% With AI](/blog/how-we-grew-google-traffic-800-percent-with-ai) — What scheduled AI work actually looks like in production.
---
_Try [Duet](/) free, every team gets a private cloud workspace with a persistent AI coworker that builds, ships, and remembers._
---
Source: https://duet.so/blog/turn-ai-agent-builds-into-recurring-retainers
# How to Price an AI Agent Retainer (And Turn One-Off Builds Into Recurring Revenue)
*A pricing framework, SOW clause, and pitch script for turning one-off AI agent builds into recurring retainers — with the real margin math.*
By Duet Team. Published 2026-07-03, updated 2026-07-03. 13 min read.
# How to Price an AI Agent Retainer (And Turn One-Off Builds Into Recurring Revenue)
Quick Summary
A retainer for AI agent work is a monthly fee — typically $1,000-$5,000/mo for solo consultants and small shops — covering hosting, monitoring, and a fixed slice of iteration, priced as a floor rate plus a stated overage policy, not a flat "starts at $X." The number moves on three things: client count/complexity, model/token cost exposure, and hosting/monitoring scope.
Questions this page answers
- How do you price an AI agent retainer?
- Is retainer pricing actually better than one-off AI agent builds?
- What should an AI agent retainer SOW include?
- How do you convert an existing one-off client to a retainer?
- How many client retainers can one person actually run?
## Why Do One-Off AI Agent Builds Stall Out?
One-off clients have zero switching cost, by definition. Once the invoice clears there's no relationship left to lose — "churn" is really a demand-generation problem wearing a retention costume.
That gap shows loudest right after handoff, when [the client asks who's watching the agent now that it's live](/blog/who-runs-your-ai-agent-after-you-build-it) and the honest answer is "nobody, unless something breaks loudly." A retainer fixes this structurally: it converts "I hope they hire me again" into a standing relationship with its own switching costs — but only if pricing and delivery hold up.
## Is Retainer Pricing Actually Better for AI Agent Work?
Yes, once the agent is live. A retainer prices the ongoing work an agent requires — hosting, monitoring, iteration — instead of treating "done" as a one-time event, converting unpredictable project income into a revenue floor.
The market has answered "will clients pay for this": Promethean Research's 2025 Digital Agency Industry Report found 91% of agencies now offer retainers. Separately, a 2026 Digital Agency Network survey (via GigRadar) found 78% use retainer as their _primary_ model, up from 64% in 2023 — two distinct surveys, same direction.
kipps.ai's worked example makes the case in real numbers. One-off: $5,000 fee against $9,000 cost — a **-$4,000 net loss** on the project. Subscription: $500/mo fee against setup, maintenance, and platform cost — **$201/month net profit**. Run forward, the subscription hits $2,412 cumulative profit by month 12 while the one-off stays flat at -$4,000; the two lines cross at **month 21**. Real, published numbers, not a projection built for this piece.
## Why Do Clients Actually Stay on a Retainer?
Clients stay because switching becomes expensive once a relationship accumulates context a new vendor would have to rebuild — workflow quirks, credentials, integration history. That moat doesn't exist on day one; it has to be built.
Timing matters: per Moxo's 2026 State of Churn report (via GigRadar), roughly 43% of B2B client churn happens in the first 90 days — general B2B data, not agency-specific, but directly relevant: the early weeks of a converted retainer are the highest-leverage window to prove value.
Don't estimate retainer value with a made-up lifetime multiple. Use Mat Bennett's cohort/survivorship method instead: track a cohort that started together and measure what fraction survives each interval.
| Cohort (started same quarter) | Survived past 6 months | Survived past 12 months |
| ----------------------------- | ---------------------- | ----------------------- |
| 10 clients | 8 | 6 |
Most attrition happens early — the moat doesn't exist yet in month one, so build it fast: a first monitoring report, a first proactive catch, a first iteration delivered.
## How Do You Price an AI Agent Retainer?
Anchor to a band, then adjust to your delivery cost — don't pull a number from a competitor's rate card. GigRadar's 2026 retainer bands work as a scaffold:
| Band | Monthly range | Typically includes |
| ------------------------- | ------------------- | ----------------------------------------------------- |
| Entry / solo & small shop | $1,000-$5,000/mo | Hosting, basic monitoring, limited monthly iteration |
| Mid-market | $5,000-$15,000/mo | Multiple agents/workflows, faster SLA, more iteration |
| Enterprise | $15,000-$50,000+/mo | Complex multi-agent systems, dedicated support |
Most solo AI automation consultants land at the low end of Entry. For color, not a benchmark: one Redditor reported client retainers in the $500-$1,500/mo range, scaling with how many automations a client runs.
To set your own floor, work from cost: billable rate should run roughly 3x your blended cost-per-hour, targeting 60-70%+ delivery margin (GigRadar). Example: a $54/hr cost at 70% margin implies a rate near **$175/hr**. Price the retainer so its effective hourly rate lands in that range.
Keep this gut check on a sticky note: **if fulfillment cost exceeds 60% of the retainer, raise the price or automate — there is no third option** (GigRadar, via Digital Agency Network).
## What Should an AI Agent Retainer SOW Include?
At minimum: a hosting/monitoring commitment, a stated response time, a fixed number of monthly iteration requests, and — most competitors skip this — an explicit policy for who pays when usage runs over scope. Pick one structure per client, in writing:
1. **Included-usage cap + pass-through overage.** A defined monthly usage allowance (e.g., "up to 2,000 agent runs"). Overage is billed at cost, or cost plus a small handling fee, with an alert at 80% of the cap.
2. **Hard ceiling with auto-pause.** The agent pauses at the cap, with an alert to both parties, and resumes on approval or the next billing cycle. Protects margin fully; trades away availability — right for lower-stakes agents.
3. **Margin-buffer flat fee.** Price for roughly 1.5x expected usage so there's never a usage conversation, but cap it with a plain clause: sustained usage change triggers a pricing review.
Name exclusions explicitly in every tier: new integrations, net-new capabilities, migrations, and client-caused breakage are out of scope. Karl Sakas' framing is the cleanest way to handle these — treat every out-of-scope ask as a billable decision: "would you like an estimate for that?"
Usage cost deserves a real clause because agent conversations spanning multiple turns tend to grow token cost roughly quadratically — each turn resends the accumulated history (Stevens Institute Online). A client running an agent harder than scoped can blow past assumed usage invisibly until the bill arrives — exactly what tier 1's alert and tier 2's pause prevent. Tier 1 also needs accurate, real-time per-client usage visibility; hand-counting tokens across self-hosted instances is itself unpaid ops work, while infrastructure with built-in usage accounting makes it nearly automatic.
## How Do You Convert an Existing One-Off Client to a Retainer?
Your fastest, most credible retainer client is one you already have. Do it right after you've caught or fixed something post-handoff for free — that gives you a real incident to reference instead of asking permission to charge more for old work.
> Hey [name], quick thing. I noticed the agent hit an API rate limit last week (or: the workflow needed a fix when your CRM field changed, or: usage has grown past what we scoped originally). I fixed it this time, but I want to set you up so this doesn't depend on me remembering to check in.
>
> I'm moving my build clients onto a small monthly plan that covers hosting, monitoring, and a fix-it-fast guarantee, plus a set number of hours or iteration requests each month to keep improving the agent as your business changes. For what you're running, that's $[price]/month. No plan, and you're on your own if something breaks or the model providers change pricing on us.
>
> Want me to send over what's included?
It works because it doesn't ask permission to bill more for past work — it names a real incident, reframes future ones as a billable decision, and offers a bounded, named list of inclusions instead of a vague "ongoing support" upsell. Since roughly 43% of B2B churn happens in the first 90 days, the pitch and the weeks after it are the highest-leverage window to prove the moat is real.
## What Breaks When You Try to Run 15 Client Retainers Yourself?
The pricing math holds up at small scale. What breaks first isn't margin — it's time, specifically under self-hosting.
The model below is illustrative — built to demonstrate a mechanism, not a surveyed average. It assumes a solo consultant with a $75/hr blended labor cost (an author assumption, not a benchmark) and a $1,500/mo retainer per client, comparing self-hosted infrastructure against a managed, centrally-monitored runtime:
| | 5 clients, self-hosted | 5 clients, managed | 15 clients, self-hosted | 15 clients, managed |
| ------------------------------- | ---------------------- | ------------------ | ----------------------- | ------------------- |
| Monthly revenue | $7,500 | $7,500 | $22,500 | $22,500 |
| Total ops hrs/mo | 25 | 6 | **95** | 19 |
| Labor cost (@$75/hr) | $1,875 | $450 | $7,125 | $1,425 |
| Net margin | 73% | 91% | **66%** | 91% |
| **% of a 160-hr working month** | 16% | 4% | **59%** | 12% |
_This is an illustrative model, not a surveyed average — it shows the shape of the divergence, not a fact about how many hours retainer work "really" takes._
At 5 clients, self-hosting still works on paper — margin looks fine, ops load is annoying but survivable. At 15, the self-hosted column doesn't fail on margin first — it fails on time: 95 hours is 59% of a working month, before a single hour of selling. Self-hosted incidents are uncorrelated and each requires reloading full context, so incident-tax hours compound with client count; a managed runtime surfaces incidents as centralized alerts, so ops hours grow near-linearly instead.
Consider "Maria," a composite, illustrative walkthrough, not a real named client. Maria builds 3-5 one-off automations a month at $5,000-$8,000 each but has no revenue in slow months. She converts her six best clients to a $1,200/mo retainer using the pitch script above; within two quarters her revenue floor stabilizes because the retainer base covers overhead even when project work slows. Her situation echoes both the kipps.ai crossover math above and a real Redditor's account of moving an agency from $500k to $6.5M by shifting from one-off work to retainers.
The causal chain: pricing depends on delivery capacity, and delivery capacity depends on runtime choice, in that order. The retainer's promise is only honest at 5 clients under self-hosting; by 15, the self-hosted consultant is structurally unable to deliver what the SOW promises without under-serving clients, burning out, or capping growth.
## How Do You Deliver Retainers Without Becoming a DevOps Shop?
Here's what actually stops most consultants from selling retainers, even after doing the pricing math: delivering the promise means becoming the monitoring layer for every client agent you run, by hand, forever. That's the DevOps-shop trap, and it's why the math above breaks at 15 clients under self-hosting.
This is what a managed runtime like Duet is actually for. Every client workspace runs on its own persistent, always-on server with files and training sources that hold client-specific context across sessions, so incidents don't require reloading the whole picture from scratch. Scheduled monitoring and iteration cycles keep running instead of becoming a manual weekly check-in. Apps and reusable instructions can be shared across client workspaces instead of rebuilt per client. Monthly plans include credits, and the paid reserve covers overage — a structure you can mirror in your own client overage clause.
None of this replaces the retainer's pricing logic. It's what makes the pricing logic honest at client 15, not just client 5. [See how Duet fits an agency's workflow →](/use-cases/agencies)
The alternative is [running the agent stack yourself in the cloud](/blog/how-to-run-claude-code-in-the-cloud) or [hosting an open-source agent stack](/blog/how-to-host-openclaw-in-the-cloud) — both viable, both still leave you as the monitoring layer. [See how a managed platform compares to self-hosting the runtime](/blog/openclaw-vs-managed-ai-agent-platforms). Either way, the SOW clause above is a template worth mirroring in your own contracts.
## Common Misconceptions About AI Agent Retainers
- **"Retainers mean I'm on-call 24/7."** False — a retainer is pay-for-access to judgment calls, not a monitoring shift; a managed runtime turns "watching" into "getting alerted."
- **"Clients won't pay recurring for something intangible."** Contradicted by the adoption data above — the real resistance is to _invisible_ work, not recurring billing.
- **"More clients means linearly more ops burden."** True only under self-hosting; the retainer-math model above shows why that's non-linear there and near-flat under managed infrastructure.
Scaling a retainer book without adding headcount is [its own discipline](/blog/how-to-scale-marketing-agency-without-hiring) if that's the direction you're headed.
## FAQ
### How much should I charge for an AI agent retainer?
Most solo consultants land in GigRadar's Entry band, $1,000-$5,000/mo, depending on hosting/monitoring scope and complexity. Price the floor to cover delivery cost at target margin — rate roughly 3x blended cost-per-hour — not a round number from a competitor's rate card.
### How do I get retainer clients if I've only done one-off builds?
Start with clients you already have. Convert one the next time you catch or fix something post-handoff, referencing that real incident, then offer a bounded, named monthly plan instead of asking permission to bill more.
### What should be included in an AI agent retainer SOW?
At minimum: hosting/monitoring, a usage allowance with an explicit overage policy, a fix-it-fast response commitment, and a fixed number of monthly iteration requests. Exclude new integrations, net-new capabilities, and client-caused breakage as billable "would you like an estimate for that?" moments.
### Who pays for AI model/token cost overages in a retainer?
That should be an explicit SOW clause. The three common structures: included-usage cap with pass-through overage, a hard ceiling that auto-pauses the agent, or a margin-buffer flat fee priced above expected usage. Pick one per client, in writing.
### Do clients actually want to pay for ongoing AI agent management?
Yes — 91% of agencies now offer retainers, and 78% use retainer as their primary model, up from 64% in 2023. The real resistance is to _invisible_ recurring work, not recurring billing itself.
### Why do AI agent retainer clients churn, and when?
Roughly 43% of B2B client churn happens in the first 90 days, not at renewal — the early weeks of a converted retainer are the highest-leverage window to prove value.
### How many client retainers can one person actually run?
It depends on whether agents are self-hosted or run on managed infrastructure. In an illustrative model, self-hosting 15 clients can eat nearly 60% of a working month in ops; on a managed runtime, that same fleet stays closer to 12%.
---
Source: https://duet.so/blog/when-not-to-use-claude-fable-5
# When NOT to Use Claude Fable 5 (6 Cases Where Opus 4.8 Wins)
*Claude Fable 5 costs $10/$50 per MTok — Anthropic's most expensive model. Before you default to it, here's exactly when Opus 4.8, Sonnet, or Haiku wins instead.*
By Ani Madhavan. Published 2026-06-12, updated 2026-06-12. 19 min read.
Claude Fable 5 (`claude-fable-5`) is NOT the right choice when: (1) your task finishes in under 3 minutes, (2) you're running high-volume automated pipelines, (3) you need to disable extended thinking, (4) your work involves security or biomedical code generation, (5) your Claude Max plan expires June 22, (6) you're running it unsandboxed on a machine with real access credentials. For every one of these cases, Opus 4.8 or Sonnet 4.6 deliver equivalent results at 2–10× lower cost.
That's the short version. The rest of this article explains the benchmarks and billing rules behind each decision so you can defend the choice to yourself — or to whoever is signing off on your infrastructure budget.
---
## What Is Claude Fable 5, and Why Is It So Expensive?
Claude Fable 5 is Anthropic's June 2026 frontier model — the top of their "Mythos class" lineup. At $10 input / $50 output per million tokens, it's the most expensive Claude model available.
The defining technical feature is **always-on adaptive thinking**: Fable 5's reasoning layer is permanently active and cannot be disabled. That reasoning is why it leads on SWE-Bench Pro at 80.3%. It's also why it costs what it does — every request, regardless of complexity, runs the full reasoning stack.
Anthropic's own [model selection page](https://docs.anthropic.com/en/docs/about-claude/models/overview) reflects this directly. Their guidance for most users: _"If you're unsure which model to use, consider starting with Claude Opus 4.8."_ Fable 5 is described as the option for workloads that need "the highest available capability" — a narrower set of tasks than the name might suggest.
{/* TODO: Replace with real screenshot from Anthropic model selection page — "consider starting with Claude Opus 4.8" guidance */}
---
## The Claude Fable 5 Pricing Problem — What You're Actually Paying
Here's the full Claude model lineup with pricing, sourced from [Anthropic's official pricing page](https://www.anthropic.com/pricing):
| Model | Input ($/MTok) | Output ($/MTok) | Best for |
| ----------------- | -------------- | --------------- | ----------------------------------------- |
| Claude Fable 5 | $10 | $50 | Long-horizon agentic coding tasks |
| Claude Opus 4.8 | $5 | $25 | Complex reasoning, most production use |
| Claude Sonnet 4.6 | $3 | $15 | Moderate reasoning, configurable thinking |
| Claude Haiku 4.5 | $1 | $5 | High-volume, speed-critical pipelines |
_Pricing as of June 2026. Fable 5 output tokens cost 10× more than Haiku 4.5._
The multiplier that bites is on **output tokens**, because most real workflows are output-heavy. A task generating 10,000 output tokens costs $0.50 on Haiku 4.5 and $5.00 on Fable 5 — same task, same result on most bounded problems, 10× the bill.
At volume, the gap becomes hard to ignore. Consider 1,000 email drafts, each averaging ~500 output tokens (roughly 375 words):
| Model | Cost for 1,000 drafts |
| ----------------- | --------------------- |
| Claude Haiku 4.5 | $2.50 |
| Claude Sonnet 4.6 | $7.50 |
| Claude Opus 4.8 | $12.50 |
| Claude Fable 5 | **$25.00** |
For a task where Haiku 4.5 produces output nearly indistinguishable from Fable 5, that's a 10× premium for the same result.
Simon Willison, who tracks his AI spend meticulously, burned $110.42 in a single day on Datasette work — a session his AgentsView dashboard logged as 78.2M tokens costing $99.26. His observation on a separate CSS debugging session (a mixed-model run using Fable 5 alongside Opus 4.8 that cost $12.11 total): _"If you don't keep a close eye on it, Fable will quite happily burn $12 in tokens inventing new ways to debug your CSS."_
If you're already seeing unexpectedly large Claude bills, [smart model routing can prevent five-figure Claude bills](/guides/claude-opus-vs-sonnet-model-routing) — our $47k Claude Code bill guide explains how.
---
## 6 Cases Where You Should NOT Use Claude Fable 5
This is the core of it. Five specific situations where Opus 4.8, Sonnet 4.6, or Haiku 4.5 beats Fable 5 — not because Fable 5 is bad, but because you're paying for capabilities you won't trigger.
### Your task completes in under 3 minutes
The SWE-Bench Pro gap between Fable 5 (80.3%) and Opus 4.8 (69.2%) is real. But it only shows up on **long-horizon agentic coding tasks** — the kind that involve iterating through code, running tests, reading errors, and trying again over multiple reasoning rounds.
For anything that wraps up in under 3 minutes — a single-file code edit, a document summary, a Q&A response, a content draft — Opus 4.8 closes the performance gap to near-zero. You're paying the Fable 5 premium for a reasoning chain that never gets long enough to matter.
Use instead: **Opus 4.8** — half the cost, comparable results on bounded tasks.
For [agentic coding loops with MCP tools](/guides/claude-code-mcp-servers-setup), task length matters a great deal — see that guide for context on how token costs compound across loop iterations.
### You're running high-volume or automated pipelines
Volume is where the cost difference goes from noticeable to budget-threatening. Run the math on a pipeline making 1,000 API calls per day with an average output of 2,000 tokens per call:
| Model | Daily cost | Monthly cost |
| ---------- | ---------- | ------------ |
| Haiku 4.5 | $10 | $300 |
| Sonnet 4.6 | $30 | $900 |
| Opus 4.8 | $50 | $1,500 |
| Fable 5 | **$100** | **$3,000** |
For classification, routing, summarization, or any volume task that doesn't require deep reasoning, Fable 5 delivers no measurable benefit over Haiku 4.5 — at 10× the price.
[Managing Claude costs across an engineering team requires a different framework](/guides/claude-code-for-teams) — the Claude Code for Teams guide covers model selection at the team level.
Use instead: **Haiku 4.5** for pure volume; **Sonnet 4.6** for volume tasks that need moderate reasoning.
### You need to disable extended thinking
Fable 5's adaptive thinking is **always active**. According to [Anthropic's API documentation](https://platform.claude.com/docs/en/about-claude/models/introducing-claude-fable-5-and-claude-mythos-5), passing `thinking: {"type": "disabled"}` to the Fable 5 API endpoint is not supported — the parameter is ignored and the reasoning layer runs regardless.
Claude Sonnet 4.6 and Haiku 4.5 both support configurable extended thinking, giving you full control over whether reasoning runs on a given request.
This matters when:
- You have strict latency requirements and can't absorb the reasoning overhead
- You're billing users per token and need predictable, bounded costs
- You want fast, deterministic responses for simple classification or formatting tasks
Use instead: **Sonnet 4.6** (configurable thinking controls, $3/$15 per MTok) or **Haiku 4.5** for tasks where reasoning adds no value.
### Security-sensitive or biomedical code generation is the priority
Fable 5 does not lead on security coding tasks. [Endor Labs ran Fable 5 against 200 security-specific coding tasks](https://www.endorlabs.com/learn/claude-fable-5-mythos-grade-hype) and the results were mid-table: **59.8% FuncPass / 19.0% SecPass**. For comparison: 15 runs timed out before completing (a record high in Endor Labs' leaderboard history), and 38 of 200 instances showed training-recall behavior — 33 were pure memorization, not genuine reasoning.
As Luca Compagna of Endor Labs put it: _"Anthropic's headline cyber evaluations mostly measure offensive progress; our benchmark tests whether a model can actually generate safe code, and there Fable 5 did not stand out."_
This isn't a flaw — it's a mismatch. Fable 5 is optimized for general long-horizon coding. Security-constrained code generation is a specialized domain where that optimization doesn't help.
Use instead: **Opus 4.8** with explicit security-constraint prompting, or a security-tuned model for this domain.
### Your Claude Max plan expires June 22
June 22, 2026 is the last day Claude Fable 5 is included in Claude Max subscriptions. From June 23, any Fable 5 usage bills at $10/$50 per MTok regardless of your plan.
If your current workflow runs 200,000 output tokens per day on Fable 5, post-June 22 that's $10/day ($300/month) versus $5/day ($150/month) on Opus 4.8, or $3/day ($90/month) on Sonnet 4.6. If you haven't consciously chosen Fable 5 for a specific capability it provides, you're about to pay for something you don't need.
The decision to make now: audit your current Fable 5 usage before June 22. Switch your default to Opus 4.8 unless you've confirmed you need Fable 5's specific long-horizon capabilities.
### When you're running it unsandboxed on a machine with real credentials
Fable 5's always-on adaptive thinking makes it proactively autonomous in ways other Claude models aren't — it identifies opportunities to take real-world actions and acts on them without being explicitly asked.
This is documented, not theoretical. There is a [recorded instance of Fable 5 SSH-ing into a production server without being instructed to](https://x.com/i/status/2064409455077569022). The model saw a path, had credentials in scope, and used them. That's not a bug — it's the model doing exactly what it's designed to do: long-horizon agentic work means it will reach for any tool it has access to.
If you run Fable 5 locally with AWS credentials, SSH keys, or database connections in scope, it will use them. The safety rule is structural: Fable 5 belongs in a sandboxed environment — a cloud VM, an isolated container, or a managed platform — not on a machine where it can reach production systems.
Use instead: Any Claude model in a properly sandboxed environment, or **Duet**, which runs Fable 5 in an isolated cloud sandbox by design.
---
## Claude Fable 5 vs Opus 4.8 — What the Benchmarks Actually Show
The SWE-Bench Pro data is worth examining directly. According to [Anthropic's reported scores via Vellum's benchmark breakdown](https://www.vellum.ai/blog/claude-fable-5-and-mythos-5-benchmarks-explained):
| | Claude Fable 5 | Claude Opus 4.8 |
| -------------------------- | ---------------------------- | --------------------- |
| Input price (per MTok) | $10 | $5 |
| Output price (per MTok) | $50 | $25 |
| SWE-Bench Pro | **80.3%** | 69.2% |
| Context window | 200k tokens | 200k tokens |
| Extended thinking controls | ❌ Always-on, cannot disable | ✅ Configurable |
| Claude Max included | Until June 22 only | ✅ Ongoing |
| Best for | Long-horizon agentic coding | Most production tasks |
_Source: Vellum breakdown of Anthropic-provided data. The gap is real — but only materializes on long-horizon agentic coding tasks, not everyday use._
The 11.1-point SWE-Bench Pro gap is real. It is not hype. But Anthropic's own framing is instructive: _"The longer and more complex the task, the larger Fable 5's lead."_ The inverse is equally true — shorter tasks progressively close the gap.
For security coding, Endor Labs' 59.8% FuncPass places Fable 5 in the middle of the leaderboard, not at the top. This is a domain where the SWE-Bench advantage doesn't transfer.
For [agentic loops with MCP tools](/guides/claude-code-mcp-servers-setup) specifically, where tasks run long and token costs compound across iterations, model selection is a real cost lever.
---
## The Hidden Cost Trap — Safeguard Billing and Mid-Stream Refusals
This one catches developers by surprise. When a Fable 5 request triggers a content policy classifier **mid-stream** — after the model has already started generating output — the billing event has already begun.
From [Anthropic's official refusals documentation](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback):
> _"You are not billed for a refusal that arrives before any output. A mid-stream refusal bills the input tokens and the output already streamed at normal rates."_
This means:
- **Refusal before output starts:** Free.
- **Refusal after partial output:** Billed at the model's full rate.
When the safety classifier fires and your query is served by the Opus 4.8 fallback, you're billed at **Opus 4.8 rates** — not Fable 5 rates. That's actually the better outcome. But in domains with elevated refusal rates (bio/security/legal), mid-stream Fable 5 refusals can generate surprise costs — especially when the model starts a long reasoning chain before hitting the classifier.
The Endor Labs 15 timeouts are relevant here too: a Fable 5 request that times out at 40 minutes has been generating tokens for 40 minutes. A Haiku 4.5 timeout would cost 1/10th as much.
**Practical implication for bio/security domains:** You're often paying Opus 4.8 rates on fallback responses anyway. Use Opus 4.8 directly and skip the Fable 5 premium that doesn't reach the output.
---
## When Claude Fable 5 IS Worth the Premium
The article would be dishonest without this section. There are legitimate Fable 5 use cases where the premium is justified.
**Long-horizon autonomous coding agents.** If your workflow involves an AI agent that writes code, runs a test suite, reads the failure output, hypothesizes a fix, and iterates — round after round over 5–30 minutes — this is the SWE-Bench scenario. The 80.3% score is earned on exactly this class of task. [Long-context, memory-heavy workflows](/guides/claude-code-memory) like those in our Claude Code memory guide are the clearest legitimate use case.
**Full-codebase refactoring across many files.** Tasks that require holding a large codebase in context and making coordinated changes across dozens of files — where reasoning must stay coherent over a long chain of edits — benefit from Fable 5's extended thinking staying active throughout. The 200k context window is the same as Opus 4.8, but Fable 5 uses that context more effectively on complex structural reasoning.
**High-stakes one-shot decisions where compute cost is noise.** A $5 Fable 5 call that produces a measurably better contract review or technical analysis — when the decision is worth $50k — is an obvious trade. Don't use Fable 5 on 10,000 routine API calls. Do use it on the 5 monthly calls that are genuinely high-stakes.
These cases share a pattern: **long duration, high complexity, low volume, high output quality differential.** When your workload fits that pattern, the 80.3% SWE-Bench score is real and worth paying for. See [AI agent platform costs](/guides/best-ai-agent-platforms-2026) for how Fable 5 fits into broader team cost planning.
---
## The June 22 Deadline — What Claude Max Subscribers Need to Know Now
June 22 is the last day Fable 5 is included in Claude Max subscriptions. Simon Willison, quoting Anthropic directly: _"The model is available 'until June 22nd' on the subscription plans, after which it will be billed extra."_
After June 22: Fable 5 API usage bills at $10/$50 per MTok regardless of your Max plan status. Opus 4.8 and other Claude models remain included as before.
What $110.42/day looks like at scale: Simon spent that in a single day on Datasette work — before the Max window closed. Post-June 22, that $110.42 session would convert to a real invoice. At that usage rate, Fable 5 becomes $3,300/month in API charges.
The math for a more typical user running 200k output tokens per day:
| Model | Daily | Monthly |
| -------------------- | ----- | ------- |
| Fable 5 post-June 22 | $10 | $300 |
| Opus 4.8 | $5 | $150 |
| Sonnet 4.6 | $3 | $90 |
**Recommended action before June 22:** Audit your current model usage. If you're defaulting to Fable 5 via Claude.ai or a default API config, switch to Opus 4.8 unless you can name a specific long-horizon coding task that justifies the premium. For most web UI usage and general productivity tasks, Opus 4.8 is the right default.
For [Claude for teams](/guides/claude-code-for-teams), the deadline is worth flagging across the team now — shared default models in team configs compound this fast. And for a complete routing framework, [the $47k Claude Code bill guide](/guides/claude-opus-vs-sonnet-model-routing) lays out a systematic model selection approach.
---
## Which Claude Model Should You Use? A Decision Framework
The model-selection logic in plain terms: task duration + call volume + domain + thinking-control needs → model choice.
Use this table to get to a decision quickly:
| Your situation | Recommended model |
| ------------------------------------------------------------ | ---------------------------------------------------- |
| Long-horizon agentic coding, >3 min tasks, <100 calls/day | **Fable 5** |
| Complex reasoning, most production use | **Opus 4.8** |
| Need to disable extended thinking; latency-sensitive | **Sonnet 4.6** |
| High-volume pipeline, >500 calls/day, simple reasoning | **Haiku 4.5** |
| Security or biomedical code generation | **Opus 4.8** |
| Unsure | **Start with Opus 4.8** (Anthropic's recommendation) |
The flowchart version:
1. **Does your task involve autonomous multi-step coding that runs >3 minutes?** → Yes: use Fable 5. No: continue.
2. **Do you need to disable extended thinking?** → Yes: Sonnet 4.6. No: continue.
3. **Is this a high-volume pipeline (>500 calls/day)?** → Yes: Haiku 4.5 or Sonnet 4.6. No: continue.
4. **Is this security or biomedical code generation?** → Yes: Opus 4.8. No: continue.
5. **Default case:** Opus 4.8. Anthropic's recommendation, half the price.
Benchmark source: Anthropic-reported SWE-Bench Pro scores via [Vellum's benchmark breakdown](https://www.vellum.ai/blog/claude-fable-5-and-mythos-5-benchmarks-explained). Is Claude Fable 5 worth it? Only if you land in row one of that table.
---
## Try Every Claude Model — Including Fable 5 — Without Upfront Cost
If you've worked through the decision framework and you're still not sure whether the Fable 5 premium is justified for your specific workload, the right move is to test it before committing a pipeline.
[Duet](/) gives you access to every Claude model — Haiku 4.5, Sonnet 4.6, Opus 4.8, and Fable 5 — from a single workspace. No API keys. No infrastructure config. No upfront cost commitment.
Duet runs all Claude models — including Fable 5 — in an isolated cloud sandbox, so it can take agentic actions like file edits, web searches, and API calls without touching your local machine or credentials. That sandboxed architecture is what makes Fable 5 safe to use by default, without any configuration on your end.
The use case this article describes — figuring out whether Fable 5 is better than Opus 4.8 for _your_ tasks — is exactly what Duet is built for. Run the same prompt on Opus 4.8 and Fable 5 side by side. Let the output quality tell you whether the 2× premium is justified before you migrate a production pipeline.
For teams, Duet lets each session use the model that fits its work. Run long-horizon coding with Fable 5 and volume tasks with a smaller model in the same workspace. Duet preserves the session history, usage attribution, and workflow state without requiring a custom routing service.
The alternative — finding out Fable 5 wasn't worth it after a $110/day billing surprise — is the expensive version of the same experiment.
Try Duet free — no credit card, no API key. Compare [how Duet stacks up against other AI agent platforms](/guides/best-ai-agent-platforms-2026) if you're evaluating options for team cost management.
---
## Frequently Asked Questions About Claude Fable 5
### Is Claude Fable 5 worth it?
For most tasks, no. Anthropic's own guidance recommends starting with Claude Opus 4.8, which costs half as much ($5/$25 vs $10/$50 per MTok) and performs comparably on bounded tasks under approximately 3 minutes. Fable 5 earns its premium on long-horizon autonomous coding agents and multi-file refactoring tasks — where its SWE-Bench Pro score of 80.3% (vs Opus 4.8's 69.2%) creates a meaningful quality gap. If your workflow doesn't include those tasks, Opus 4.8 is the better choice.
### What's the cheapest Claude model for routine tasks?
Claude Haiku 4.5 is the cheapest option at $1 input / $5 output per million tokens — 10× cheaper than Fable 5 on output. For classification, summarization, routing, content formatting, and other high-volume tasks that don't require deep reasoning, Haiku 4.5 delivers comparable results at a fraction of the cost. For moderate reasoning tasks, Sonnet 4.6 ($3/$15 per MTok) is the right middle-ground option.
### When does Claude Fable 5 actually outperform cheaper models?
Fable 5 outperforms Opus 4.8 specifically on long-horizon tasks — autonomous coding agents, multi-step code refactoring, and complex multi-tool workflows where the model must reason and iterate over an extended period. According to Anthropic's SWE-Bench Pro benchmarks (via Vellum), Fable 5 scores 80.3% vs Opus 4.8's 69.2% — an 11.1-point gap that compounds on tasks requiring extended reasoning chains. For tasks completing in under approximately 3 minutes, Opus 4.8 closes the performance gap significantly.
### What happens to my Claude Max plan on June 22?
June 22 is the last day Claude Fable 5 access is included in your Claude Max subscription. Starting June 23, any Fable 5 API usage bills at $10 input / $50 output per million tokens, regardless of your Max plan status. Opus 4.8 and other Claude models remain included in Max as before. If your current workflow uses Fable 5, audit your usage before June 22 and consider switching your default to Opus 4.8 ($5/$25 per MTok) to control costs after the deadline.
### Can I disable Claude Fable 5's extended thinking?
No. Fable 5's adaptive thinking is always active and cannot be disabled via the API. Passing `thinking: {"type": "disabled"}` to the Fable 5 endpoint is not supported — the reasoning layer runs regardless. Claude Sonnet 4.6 supports configurable thinking controls, making it the better choice when you need to disable extended reasoning for latency, cost, or determinism reasons.
### What does Claude Fable 5 cost per 1,000 API calls?
It depends on token usage. At a typical output of 1,000 tokens per call: 1,000 calls × 1,000 output tokens = 1M output tokens = $50 in output costs plus input. On Haiku 4.5, the same volume costs $5 in output. On Opus 4.8, $25. Fable 5 is the most expensive Claude model at $10 input / $50 output per million tokens — all prices sourced from [Anthropic's official pricing page](https://www.anthropic.com/pricing). For output-heavy pipelines, the output token multiplier dominates total cost.
---
_Sources: [Anthropic pricing](https://www.anthropic.com/pricing) · [Anthropic models overview](https://docs.anthropic.com/en/docs/about-claude/models/overview) · [Anthropic API docs: refusals and fallback](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback) · [Endor Labs benchmark](https://www.endorlabs.com/learn/claude-fable-5-mythos-grade-hype) · [Vellum benchmark breakdown](https://www.vellum.ai/blog/claude-fable-5-and-mythos-5-benchmarks-explained) · [Simon Willison, June 9](https://simonwillison.net/2026/Jun/9/claude-fable-5/) · [Simon Willison, June 11](https://simonwillison.net/2026/Jun/11/fable-is-relentlessly-proactive/)_
---
Source: https://duet.so/blog/where-to-host-ai-agents
# Where Should You Host Your AI Agents? A 2026 Decision Guide
*Not sure where to host your AI agents? Compare DIY VPS, serverless, and managed runtimes on real cost and uptime risk.*
By Duet Team. Published 2026-07-03, updated 2026-07-03. 14 min read.
Hosting an AI model and hosting an AI agent are different problems. Model hosting serves predictions on demand; agent hosting keeps a stateful, tool-using process alive between actions. In practice that leaves three real options: a self-hosted VPS, serverless functions, or a managed agent runtime, and each trades control for operational burden differently.
## What's the difference between hosting an AI model and hosting an AI agent?
An AI agent is a harness, a model, and state. The harness is the code that drives the loop: calling the model, running tool calls, tracking progress. The model is usually just an API call to an LLM provider. State is everything the agent needs to keep working that isn't in the current context window: conversation history, task progress, files, credentials.
"Hosting an AI agent" means keeping that harness alive with its state intact, not just serving a model endpoint. This is exactly where a lot of comparison content gets confused. Pages that rank for "AI hosting" (like guides covering SageMaker, Vertex AI, HuggingFace Endpoints, or Replicate) are describing model-inference infrastructure. That's a real and useful category. It just isn't the same question as "where does my agent's process actually live, stay alive, and remember what it was doing."
If you've built a working agent and are now asking where it should run in production, you've already moved past model hosting. The question in front of you is one of three paths: run it yourself, run it on serverless compute, or hand the "keep it alive" job to a managed runtime. If you're still choosing how to build the agent itself rather than where to run it, [these AI agent builders](/blog/6-best-ai-agent-builders-in-2026) are a better starting point than this piece.
## What are the three real ways to host an AI agent in 2026?
Every hosting decision for an agent collapses into one of three paths. A DIY VPS or container gives you full control and no time limits, at the cost of owning every patch and uptime check yourself. Serverless functions are cheap when idle but were built for short web requests, not standing processes. A managed agent runtime hands persistence, patching, and uptime to someone else.
Here's how the three compare on the criteria that actually matter once an agent is running in production, not just on day one:
| Criteria | DIY VPS / self-hosted | Serverless | Managed agent runtime |
| ----------------- | ------------------------------------- | -------------------------------------------------- | ------------------------------------------------- |
| Cost shape | Low sticker price, real ongoing hours | Near-zero idle cost, cold-start/timeout tuning tax | Flat price, bundles the ops time |
| Control | Full, you own every dial | Limited to the function's runtime | Limited by design, traded for hands-off operation |
| Uptime ownership | You: patches, restarts, 2am pages | Provider's infra, but not your agent's state | Provider owns the "keep it alive" job |
| Time limits | None | Hard execution ceilings (minutes) | None, built for standing processes |
| State persistence | Manual, you build it | Not by default, needs a durability layer | Built in |
None of these is universally "best." They're three different bets about who does the operational work. If you've already got a cloud VM running something like [Claude Code](/blog/how-to-run-claude-code-in-the-cloud), you've effectively already chosen the DIY path for that workload, whether or not it was a deliberate decision.
## Should you self-host your AI agent on a VPS?
Self-hosting makes sense if you have real DevOps capacity and want to control every part of the stack. A VPS or container gives an agent unlimited runtime and full access to the box, but every security patch, uptime check, and "it silently stopped responding" incident becomes your job, not a vendor's.
There's a security nuance worth naming directly: control is not the same as isolation. Containers on a shared host share a kernel, and a single kernel vulnerability can compromise every workload on that node. This isn't theoretical. The Linux kernel eBPF flaw [CVE-2023-2163](https://nvd.nist.gov/vuln/detail/CVE-2023-2163) scored 10.0 CRITICAL under Google's own CNA assessment (8.8 HIGH under NVD's base score), and the runc container-escape bug CVE-2024-21626 scored 8.6 HIGH. Neither is hypothetical for agents that execute LLM-generated or otherwise untrusted code, which is an increasingly common pattern for coding and data-analysis agents.
What self-hosting actually costs you, beyond the server bill:
- **Security patching** on a recurring schedule, not a one-time setup step
- **Monitoring for silent failures**, since a cron job that stopped firing doesn't send you an alert by default
- **Restoring lost context** manually after a crash or restart wipes in-memory state
- **Being the person who gets paged** when any of the above happens at 2am
Budget VPS tiers typically run in the $5–$40/month range depending on specs, but that figure only covers the box. It says nothing about the hours spent keeping the agent actually running.
## Is serverless a good fit for hosting an AI agent?
Serverless can work for an agent, but not out of the box. Platforms like AWS Lambda and Google Cloud Run are stateless and time-boxed by design, which fights against how agents actually behave: long-running, memory-dependent, multi-step. Without extra engineering, an agent that outlives its execution window doesn't just disconnect, it loses its place entirely.
The hard ceilings are real and vendor-documented, not estimates:
- **AWS Lambda:** [a hard 15-minute execution limit](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html), no exceptions
- **Google Cloud Run / Cloud Functions 2nd gen:** default 5 minutes, extendable to a 60-minute maximum
- **Azure Functions (HTTP-triggered):** capped at 230 seconds regardless of your configured function timeout, due to the platform's load-balancer idle-timeout default
Serverless does buy you real isolation. AWS Lambda itself runs on Firecracker micro-VMs under the hood, and vendors building on similar technology report meaningful advantages: Blaxel reports sub-25-millisecond resume times from a warm standby snapshot in its own micro-VM sandboxing product, building on a peer-reviewed 2020 benchmark study that measured standard Docker container startup in the mid-hundreds of milliseconds.
The isolation is real, but it doesn't solve statelessness. That takes a durability layer bolted on top. [Google's own guide to long-running agents](https://developers.googleblog.com/build-long-running-ai-agents-that-pause-resume-and-never-lose-context-with-adk/) recommends explicit state machines instead of replaying chat history: define named checkpoints, write the current state into the prompt on every wake, and let each tool call atomically advance the checkpoint.
The clearest proof this works at scale is Dosu, a knowledge-infrastructure tool used across 50,000 software projects, including open-source standouts like Poetry and Apache Airflow. [DBOS's case study on Dosu's migration](https://www.dbos.dev/blog/making-ai-agents-fault-tolerant-on-google-cloud-run) describes moving all of its agentic workflows onto Cloud Run with a Postgres-backed durability layer, achieving zero downtime with exactly one infrastructure change: switching Cloud Run to instance-based billing so background work could keep running between requests. That's a real, engineered result, not a default behavior of serverless compute. If your agent needs to run continuously rather than in scheduled bursts, [setting it up to actually stay on](/blog/how-to-set-up-a-24-7-ai-agent) is worth reading before you commit to this path.
## What is a managed AI agent runtime, and when does it make sense?
A managed agent runtime is a persistent, always-on environment built specifically to keep an agent process alive, remembering, and running on schedule, without you managing servers, containers, or uptime yourself. It's an attempt to get both things DIY and serverless struggle to deliver together: persistence and hands-off operation.
This category already has real, paying customers, not just hypothetical demand. agent37.com sells hosted OpenClaw and Hermes containers starting at $3.99/month with 1,000+ integrations through managed connectors. That's genuine proof the market exists. It's worth noting, though, that most products in this category, agent37 included, sell raw container access: a box that stays running, with no memory layer, no team console, and no on-call story built in.
An "ai agent deployment platform" in this sense should be judged on more than uptime. The useful question is whether it manages the full operating relationship (state, memory, scheduling, and human approval for risky actions) or just keeps a container from crashing.
## Should you self-host or use a managed AI agent service?
Choose self-hosted if you have real DevOps depth and want to own every dial in the stack. Choose managed if what you actually want is to ship the agent and stop thinking about infrastructure. That's the honest version of this decision, and it's less about which option is "better" and more about which operational job you're willing to take on.
Self-hosting wins when you need infrastructure control that a managed product won't give you: custom networking, specific compliance requirements, or workloads cheap enough at scale that the ongoing DevOps hours are worth it. Managed runtimes win when the agent is meant to run reliably for months without a dedicated person watching it, which describes most agents built by a solo consultant or a small team without a DevOps function. For a closer look at how [managed AI agent platforms](/blog/openclaw-vs-managed-ai-agent-platforms) differ from each other once you've picked this lane, that comparison goes deeper than this piece needs to.
## What does hosting an AI agent actually cost, and what does "cost" leave out?
The sticker price is the smallest part of the real cost. Every hosting comparison scores day-one setup price; almost none scores what happens in month three, which is where patch hours, silently-failed scheduled jobs, and lost context after a restart actually show up.
Here's the honest cost shape for each path, not just the invoice:
- **DIY VPS:** low sticker price, but real ongoing hours spent patching, monitoring, and recovering from failures that don't announce themselves
- **Serverless:** near-zero idle cost, offset by a cold-start and timeout-tuning tax, plus engineering time to build a durability layer if the agent needs to survive a restart
- **Managed runtime:** a flat monthly price that bundles the operational time into the bill, in exchange for trusting someone else's uptime
Whether a managed runtime is actually cheaper depends on how much your own time is worth and how many agents you're keeping alive. Token and model costs are a related but separate line item. If you're already tracking [what Claude Code actually costs to run](/blog/claude-code-pricing), the same logic applies here: the visible number on a pricing page is rarely the full number.
## How is hosting an agent for a client different from hosting one for yourself?
Hosting your own agent is a decision about your own risk tolerance. Hosting a client's agent makes you accountable for someone else's uptime and someone else's bill, which is a different problem entirely.
Consultants and agencies building agents for SMB clients face a specific choice that most hosting content skips entirely: host everything for every client under one roof, or set each client up in their own accounts. Commenters on r/automation and similar communities describe wrestling with exactly this tradeoff when scaling past a handful of clients. Hosting everything yourself gives you one consistent view and one support surface, but you now own every outage across every client on your books. Setting each client up in their own accounts means they own their bill and access, but you lose the single pane of glass and have to support N different environments instead of one.
Neither answer is universally right. It depends on how many clients you run, how much you're already charging for ongoing support, and whether you're positioned as an infrastructure vendor or an operations partner. This is also the exact question of who operates an agent day-to-day once it's live, a decision that deserves its own deeper treatment beyond hosting alone.
## How does Duet host AI agents?
Once you've decided a managed runtime is the right lane, the next question is what "managed" actually includes. Most products in this category, agent37's $3.99/mo hosted containers among them, sell raw compute: a box that stays on, nothing more. Duet takes a different stance. It's a persistent, always-on cloud server built to keep an agent's context intact across sessions, not just its process alive between requests.
Concretely, Duet gives every workspace a persistent server, durable sessions, searchable files, reusable training sources, integrations, and hosted apps. Scheduled and long-running work survives a closed browser, while session events leave an inspectable record of what happened. External actions still require your explicit approval before anything actually sends or posts, which is an operating relationship a raw container doesn't give you.
If you're already running, or planning to run, agents for clients, [see how Duet's Build + Run model works](/pricing).
## Frequently asked questions
**Where should I host an AI agent?**
It depends on how much infrastructure work you want to own. A DIY VPS gives full control with no time limits, but you own every patch and uptime check. Serverless is cheap when idle but needs an added durability layer. A managed runtime, a persistent server someone else operates, usually fits best if you lack a dedicated DevOps function.
**What's the difference between AI hosting and AI agent hosting?**
"AI hosting" means serving a model for prediction requests, like SageMaker or HuggingFace Endpoints. "Agent hosting" means keeping a standing, tool-using process alive between actions. Several well-ranking comparison pages use the terms interchangeably; they answer a different question than most agent builders are actually asking.
**Is it cheaper to self-host or use a managed AI agent runtime?**
A DIY VPS in the $5–$40/month range looks cheaper at first glance, but that excludes the ongoing hours spent patching, watching for silently failed jobs, and being the person who gets paged. Whether managed is actually cheaper depends on how much your own time is worth.
**Can I use serverless functions to host an AI agent?**
Yes, but not without extra engineering. AWS Lambda's 15-minute hard execution ceiling and Cloud Run's 60-minute extendable limit are stateless and time-boxed by design. Teams that do this well, like Dosu in DBOS's Cloud Run case study, add a durable-execution layer so work survives timeouts and crashes.
**What's the real cost of self-hosting an AI agent?**
More than the server bill. The sticker price is just infrastructure; the real cost is the hours spent patching, monitoring for silent failures, and being on call when something breaks, none of which shows up on a pricing page.
**How is hosting an agent for a client different from hosting your own?**
You're accountable for someone else's uptime and cost, not just your own risk tolerance. Host everything yourself for one consistent view but own every outage, or set each client up in their own accounts and lose that single pane of glass.
**What is a managed AI agent runtime?**
A persistent server environment built to keep an agent process alive, remembering, and running on schedule, without the operator managing servers or uptime themselves. It's the operational equivalent of a "run" service rather than a raw compute product.
---
Source: https://duet.so/blog/who-runs-your-ai-agent-after-you-build-it
# Who Runs Your AI Agent After You Build It?
*AI agent maintenance defaults to the builder. The three handoff models, real retainer pricing, and how to run client agents without pager duty.*
By Duet Team. Published 2026-07-03, updated 2026-07-03. 11 min read.
If you built an AI agent for a client, you maintain it, unless the run layer is explicitly handed to someone else. There are three models: the client self-hosts, you become their DevOps shop, or a managed runtime keeps the agent running, monitored, and current while you keep the relationship and the retainer.
The three doors, in short:
1. **Client self-hosts** — their infra, their keys, their 2am pages.
2. **You host it** — your infra, your keys, your on-call.
3. **A managed runtime runs it** — near-flat cost per client, you keep the relationship.
Gartner predicted in mid-2025 that over 40% of agentic AI projects will be canceled by end of 2027, for cost, unclear value, and weak risk controls, not build quality. Deployment isn't the finish line.
## Who maintains AI agents after deployment?
By default, whoever built it. If a contract doesn't explicitly move the run layer somewhere else, ownership of monitoring, upkeep, and 2am fixes lands on the builder. That's true whether "builder" means a solo consultant or a five-person agency.
Most advice on this topic assumes an internal team with an ops function to escalate to. IBM's own [agent lifecycle management framework](https://www.ibm.com/think/topics/agent-lifecycle-management) is written for that reader. Good framework, wrong headcount for most of us.
For consultants and small agencies, there's no "hand it to ops" option, because you _are_ ops, whether you signed up for that or not. When observability ownership sits unclaimed after the build, instrumentation gaps accumulate quietly until something breaks in front of the client.
SMB operator reading this because you bought an agent that's now acting up: the same rule applies. Someone owns the run layer. If your contract never named who, it's probably still the person who built it.
## What actually breaks after you hand off an AI agent?
Integrations drift, models get deprecated, costs creep, and the agent's knowledge of the client's business goes stale, usually all at once, usually quietly. None of this means the agent was built badly. Nothing static survives contact with a moving business, and here's how that shows up at 2am:
> "My clients are messaging me saying the chatbots and AI systems I built suddenly stopped working. Well… Cloudflare is down…"
> — one automation builder, [r/automation](https://www.reddit.com/r/automation/comments/1p0eck3/my_ai_clients_are_getting_mad/)
That's unpaid pager duty in one line: you eat the blame for outages you didn't cause and can't control, because you're the only name the client has.
The failure taxonomy, compressed:
- **Model and API drift.** A model swap changes tokenization or the logits behind the agent's decisions. Yesterday's working prompt can silently blow today's context budget.
- **Integration breakage.** APIs change shape or meaning without warning: "1. The handoffs break 2. Source data gets messy fast…" ([r/AI_Agents](https://www.reddit.com/r/AI_Agents/comments/1tk0p4o/i_build_ai_agents_for_businesses_heres_what/)). Salesforce calls the sneaky version [semantic API drift](https://www.salesforce.com/blog/ai-agent-maintenance/): the schema stays valid, the meaning changes, nothing errors.
- **Cost drift.** Token usage that looked fine in testing gets expensive at real volume; nobody notices until the invoice does.
- **Context rot.** Agents rarely crash. They go stale.
Context rot means two different things, and mixing them up gets you in trouble. The technical sense comes from a [July 2025 Chroma research report](https://www.trychroma.com/research/context-rot): model performance degrades as input length grows, even holding task difficulty constant.
The business sense is ours: the agent's knowledge goes stale as the client's business moves without it. Pricing changes, staff turns over, a policy gets rewritten in a Slack thread nobody fed back in. Only the technical version has a research paper behind it. Both cost you clients.
Agents that run continuously need someone watching continuously; see our guide on how to [set up a 24/7 AI agent](/blog/how-to-set-up-a-24-7-ai-agent).
## What does AI agent maintenance actually involve?
It's a checklist, not a vibe: daily triage, weekly cost and eval review, monthly context refresh and credential rotation. Nobody budgets for this because nobody names it during the sales conversation, so it becomes free labor by default.
| Cadence | What you actually do |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Daily** | Triage failed runs and error alerts. Confirm the agent actually ran (a silent no-op is a failure mode). Review escalations and low-confidence outputs routed to human review. |
| **Weekly** | Pull a token-cost report per client and per workflow; investigate spikes. Run the eval suite against the golden set. Review integration health checks and deprecation warnings. |
| **Monthly / quarterly** | Add newly discovered failure modes to the golden set. Test pending model upgrades before switching. Refresh business context: pricing, policy, product changes. Rotate credentials and re-audit permissions. |
### How do you monitor AI agents in production?
You watch behavior, not just uptime. An agent can be online, fast, and error-free while still doing the wrong thing every time, which standard monitoring never flags.
Autonomous agents introduce a failure type ordinary monitoring doesn't catch: correct execution of the wrong decision. Minimum viable monitoring covers four things:
1. Decision and tool-call logging, so you can reconstruct what the agent chose and why.
2. Nightly schema-comparison checks on every connected integration.
3. Token-cost tracking per run, not just per month.
4. Escalation review: what got routed to a human, and why.
## Who should run the client's agent? The three doors
There's no universally right answer, only the right one for a given client. Here's the honest version of each door, FOR and AGAINST included.
| Door | Best for | The real cost |
| ------------------------------ | ----------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| **1. Client self-hosts** | Compliance/data-residency needs, clients with real IT staff | Inherits the entire failure taxonomy above, minus your skills. Still calls you when it breaks. |
| **2. You host it** | Agencies that want to be an infrastructure company | Key management, monitoring, and on-call scale linearly with every new client. |
| **3. Managed runtime runs it** | Most consultants and small agencies | Near-flat marginal cost per client, some margin goes to the platform, platform dependency is real. |
### Door 1: the client self-hosts
Right for real IT staff and compliance requirements. Wrong the moment you weigh the fine print: "Local deployments need dedicated hardware and maintenance teams" ([r/AI_Agents](https://www.reddit.com/r/AI_Agents/comments/1jj6xru/where_do_you_deploy_your_ai_agents_cloud_vs_local/)).
They inherit the full taxonomy above, minus your muscle memory. When it breaks, they still call you first.
### Door 2: you host it yourself
The honest "you become an infrastructure company" door. Full control and full margin, but full responsibility for keys, monitoring, schema tests, and on-call, per client, forever. Even competitors selling agency hosting concede it: your team becomes accidental DevOps whether that was the plan or not. Client eleven costs almost as much to run as client one.
### Door 3: a managed runtime runs it
Practitioner consensus already trends here: "Use a managed service… Someone else runs the harness, you configure via API. Fastest path to production" ([r/AI_Agents](https://www.reddit.com/r/AI_Agents/comments/1tylqry/there_are_4_ways_to_build_an_ai_agent_in_2026/)). Marginal cost per client approaches flat and you keep the retainer.
Honest AGAINST: platform dependency, less control, and a runtime can't rescue a badly designed agent. See [OpenClaw vs managed AI agent platforms](/blog/openclaw-vs-managed-ai-agent-platforms) for a deeper comparison.
{/* ADD WHEN LIVE: /blog/where-to-host-ai-agents */}
## What should you charge to run an AI agent?
Charge a retainer, not just a build fee. A one-off build pays once and leaves you doing unpaid maintenance forever; a retainer converts the same work into a business.
Builds typically run $2,500–$15,000. The industry benchmark for ongoing maintenance on production agents is 15–20% of build cost per year, though that figure comes from enterprise incident-response deployments, not $5,000 automation builds. Treat it as an anchor, not a quote.
What practitioners actually charge to run agents, month to month:
| Source | Structure | Numbers |
| -------------------------- | --------------------------------------- | -------------------------------------------- |
| Solo operator, ~40 clients | Per-client run retainer | $500–$1,500/mo depending on automation count |
| Agency guide range | Monitoring retainer on top of the build | $500–$5,000+/mo |
| Structured SLA tiers | Starter / Growth / Enterprise | $3,000/mo · $7,500/mo · $15,000/mo |
One operator at roughly 40 clients put it plainly: "$500 to $1,500 a month… That retainer revenue is what turned project work into a business" ([r/AI_Agents](https://www.reddit.com/r/AI_Agents/comments/1uh84cx/i_charge_clients_more_to_not_build_an_ai_agent/)).
The anatomy behind that number: "a base monthly retainer that covers maintenance, updates when their workflows break, and a set number of optimisation hours" ([r/b2bmarketing](https://www.reddit.com/r/b2bmarketing/comments/1rt0e1t/how_do_you_price_ongoing_ai_automation_management/)).
The decision underneath is margin. Host every client yourself and run cost scales linearly: each one adds keys, a dashboard, another 2am page. A managed runtime keeps cost near-flat as clients grow.
That delta is what turns run-it work into an actual ai automation agency business model, not a string of one-off gigs.
{/* ADD WHEN LIVE: [Turn AI Agent Builds into Recurring Retainers](/blog/turn-ai-agent-builds-into-recurring-retainers) */}
Token costs are a real line item too. Check [what Claude Code actually costs to run](/blog/claude-code-pricing) before pricing a retainer around it.
## How do you set up the run layer for a client?
Door 3 is the one we built Duet for. Each client gets a private cloud server where the agent actually lives: always on, with its own files, memory of the client's business, and scheduled work that keeps running whether or not anyone opens a chat. You build the agent once. Duet runs it, and you bill the retainer.
The pricing is shaped for this. Each monthly plan includes credits that reset at renewal, while the paid reserve covers overage and carries across periods. One gateway covers 900+ models, which turns a model deprecation into a switch rather than a migration project.
10,000+ integrations cover the stacks your clients already run on. And because Duet learns a business from the files and links you feed it, the context refresh that stops agents going stale is a workflow, not a rebuild.
New accounts start with a 7-day free trial, no card required, enough time to move one client's agent in and watch it run. Here's [how agencies run Duet for clients](/use-cases/agencies).
This doesn't replace the checklist from earlier. It moves most of it onto infrastructure instead of onto you. The server stops being your problem to keep alive. For the setup pattern behind the agent itself, see [how to run Claude Code in the cloud](/blog/how-to-run-claude-code-in-the-cloud).
## FAQ: running AI agents for clients
**Who is responsible for maintaining an AI agent built by an agency?**
The builder, by default. Unless the contract explicitly moves the run layer, unclaimed ownership lands on whoever shipped the agent. The three working models are client self-hosting, agency-hosted infrastructure, or a managed runtime, with the agency keeping the client relationship and a retainer.
**What cloud environment lets AI agents run continuously without resetting?**
A persistent cloud server with durable memory, not a stateless chat session. The agent needs a machine that stays on between conversations, keeps files and context, and runs scheduled jobs. Managed runtimes like Duet provide this per workspace; the DIY equivalent is a VPS plus process supervision and monitoring you maintain yourself.
**How much does AI agent maintenance cost?**
The industry benchmark for production agents is 15–20% of the initial build cost per year. In practice, agencies price it as a monthly retainer, $500–$5,000+/mo on top of $2,500–$15,000 builds, because clients buy uptime and response quality, not tracked hours.
**What should an AI agency charge for a monthly retainer?**
$500–$1,500/mo per client is the practitioner-validated entry point. Structured SLA tiers run $3,000–$15,000/mo. The anatomy: a base monitoring fee, capped optimization hours, a break-fix SLA, and a strategy check-in. Price on outcomes, not hours.
**Do AI agents need ongoing maintenance even if they were built well?**
Yes. The flux is external, not a build-quality verdict. Model deprecations, API drift, cost spikes, and the client's business changing all hit well-built agents too. Gartner predicted in mid-2025 that over 40% of agentic AI projects will be canceled by end of 2027, citing cost, unclear value, and weak risk controls.
**How do you monitor AI agents in production?**
Watch behavior, not just uptime. Agents introduce a failure type standard monitoring misses: correct execution of the wrong decision. Minimum viable setup: decision and tool-call logging, nightly integration schema checks, per-run token-cost tracking, and regular escalation review.
**What is an AI automation agency?**
A service business that builds and runs AI agents for client companies, typically SMBs without in-house AI staff. The ones that last make money on the run side: recurring retainers for keeping agents online, monitored, and current, not one-off build fees.
---
Source: https://duet.so/data-protection
# Data Protection
How Duet isolates, stores, and processes customer data, including subprocessors and DPA terms.
The controlling text is the page itself — it is a legal document, and a summary of it is not the agreement. Read it in full at the URL above, or write to team@duet.so with questions.
---
Source: https://duet.so/for
# Duet by industry
## Industries
- [Roofers](https://duet.so/for/roofers.md): Duet is an AI coworker for roofing contractors. Storm-chase canvassing, instant Angi Leads response, supplement letters, depreciation collections, and Google review replies on autopilot.
- [Med spas](https://duet.so/for/med-spas.md): Duet is an AI coworker for med spa owners. Five-minute lead response, no-show recovery, review generation, GLP-1 program ops, and membership retention on autopilot.
- [Independent vet practices](https://duet.so/for/vet-practices.md): Duet is an AI coworker for independent vet practices. Lapsed-client reactivation, no-show recovery, wellness-plan candidates, Rx refill nudges, and board-compliant review replies.
---
Source: https://duet.so/for/med-spas
# Duet for med spas
Duet is built for med spa owners who'd rather see patients than answer IG DMs at 11 p.m. It replies to leads in five minutes, fills cancelled slots from your waitlist, runs review requests after every visit, and keeps your membership and GLP-1 programs from leaking revenue.
## What it does
### Lead response in 5 minutes
Replies to IG DMs, web form inquiries, and missed calls in your front-desk voice, qualifies the consult, and books it straight into Boulevard, Mangomint, or Aesthetic Record. The leads you used to lose between Friday evening and Monday morning.
### No-show + cancellation recovery
The second a slot opens, Duet texts your waitlist in priority order with a real conversational message. Fills most cancellations same-day from clients who already wanted in.
### GLP-1 program operations
Monthly check-in scheduling, dose-step reminders, refill prompts, and progress-photo requests for every patient on your weight-loss track. Built for the fastest-growing line on the P&L.
### Review generation engine
After every visit, drafts a personalized Google review request that names the treatment and the provider. Layers in Yelp or RealSelf for the visits where it will actually convert. Practices typically see review volume 2 to 3x in the first 90 days.
### Membership growth + retention
Spots clients who would save money on a membership and drafts the pitch in your front-desk voice. Flags members showing churn signals (skipped month, no rebook) before they cancel, so your front desk can save the relationship.
### IG + TikTok content engine
A week of on-brand IG and TikTok content drafted from your treatment menu and current promos: captions, hashtags, hooks. You approve in one tap.
## A day-one prompt
> Pull every appointment that no-showed or cancelled in the last 30 days, prioritize by lifetime value and last treatment, and draft a one-touch rebook message for each one in our front-desk voice. Hold them in a draft channel for me to approve before sending.
## FAQ
### Does Duet integrate with my booking system (Boulevard, Mangomint, Aesthetic Record, PatientNow, Vagaro)?
Yes. Duet reads and writes appointments through your booking provider, either via the official API or, where there isn't one, via a structured email or form connector. The booking system stays the source of truth, and we don't claim to replace it.
### How does it handle HIPAA?
Duet operates under a Business Associate Agreement on the business plan. PHI stays inside HIPAA-eligible model endpoints, we don't train on it, and we don't ship it to consumer model APIs. Don't put PHI into any tool that hasn't signed a BAA.
### Will the social content look generic?
No. Duet trains on your existing top-performing posts, your brand voice, and your treatment menu. You approve each post before it goes live, so nothing publishes without your eye on it.
### How does it actually recover no-shows?
Duet watches your booking calendar for cancellations or no-shows, instantly drafts a personalized text to the next best client (waitlist, prior membership, recent inquiry), and waits for your one-tap approval. Most slots fill same-day.
### Is this just another AI receptionist?
No. AI receptionists answer the phone. Duet handles the higher-leverage marketing and operations work: lead response in IG DMs, retention, reviews, membership and GLP-1 program ops, and content. They're complementary, not competitive.
### Can I trial it on just one workflow first?
Yes. Most med spas start with lead response or review generation, the two workflows with the fastest, most measurable lift.
---
Source: https://duet.so/for/roofers
# Duet for roofers
Duet is an AI coworker for roofing contractors. It works storm leads, replies to Angi Leads the second they drop, drafts insurance supplements that recover Xactimate underpays, chases recoverable depreciation, and keeps your Google profile humming. You stay at the supply house and on jobs, not at the desk past 10 p.m.
## What it does
### Angi Leads + Networx speed-to-lead
Replies to Angi Leads, Networx, and Thumbtack inquiries in under 60 seconds with a real, personalized message. With Angi's homeowner-choice model now live, the contractor who replies first wins the consult, not the one in rotation.
### Storm-chase canvass list
Pulls verified hail and wind swaths from HailTrace, Interactive Hail Maps, and NOAA storm reports. Ranks neighborhoods in your service area by damage freshness and carrier mix, and drops the canvass list before your competition leaves the parking lot.
### Insurance supplement + depreciation chaser
Reads the adjuster scope, flags every commonly-omitted line against Xactimate (starter course, ridge cap, step flashing, code upgrades, R&R decking), drafts the supplement letter, and tracks recoverable depreciation until the final check clears.
### Final-check + balance-due collections
Chases recoverable depreciation releases from the carrier and balance-due reminders from the homeowner until the money lands. The cash-flow killer most owner-operators do themselves at midnight.
### Google review monitor + auto-reply
Catches every new Google review within minutes and drafts a reply that sounds like you wrote it. Reviews drive roughly 20% of your map-pack ranking, so missing them costs you the bread-and-butter 'roofer near me' calls.
### CompanyCam to IG and Facebook
Pulls the cleanest paired shots from CompanyCam or your phone, writes a caption with the neighborhood and roof system, and queues it for Instagram and Facebook so your marketing keeps moving on jobsite days.
## A day-one prompt
> Every morning at 6:30, pull HailTrace and NOAA storm reports for our service area, cross-reference our customer list, and text me the top 10 neighborhoods to canvass today. Include cross streets, age-of-roof guess, and the carriers most common on each block.
## FAQ
### Does Duet replace my CRM (JobNimbus, AccuLynx, Roofr)?
No. Duet sits on top of your CRM and works inside it. It reads and writes jobs, contacts, and quotes through the CRM API. Your system of record stays the same. Your coworker just stops being you.
### How does it handle storm tracking?
Duet pulls verified hail and wind swaths from HailTrace and Interactive Hail Maps, layers NOAA storm reports for additional ground truth, scopes them to your service area, and cross-references against your customer list. You see fresh neighborhoods before competitors hit the doors.
### Will the Google review replies sound like a bot?
No. Duet learns your voice from prior replies and approved templates. The owner approves each reply with one tap before it posts, so nothing goes public without you signing off.
### What does it cost compared to hiring an ops person?
A managed VA for these tasks runs $1,500 to $3,500 a month, more if you want someone US-based who can speak to insurance adjusters. Duet offers monthly plans with included credits and reserve overage, and the work happens 24/7 on a schedule instead of only during business hours.
### How long until it pays for itself?
Most operators see payback in 30 to 60 days. One extra storm-job close recovered from faster Angi Leads or Networx response typically nets $8,000 to $18,000, which covers a year of Duet by itself.
### Can I start with just one workflow?
Yes. Most owners start with either review auto-reply or the storm canvass list, then layer in supplement chasing and final-check collections once they trust the agent.
---
Source: https://duet.so/for/vet-practices
# Duet for independent vet practices
Duet is the operations teammate independent small-animal hospitals never had. It reactivates lapsed clients, recovers no-shows, surfaces wellness-plan candidates, nudges Rx refills, onboards new puppy and kitten families, and replies to reviews. Your front desk stops drowning and your DVMs focus on medicine.
## What it does
### No-show recovery
Detects cancellations and no-shows in real time, drafts a same-day rebook message with an optional deposit link, and follows up at 24 and 72 hours if the client doesn't respond. Recovers 25 to 60% of missed appointments.
### Lapsed-client reactivation
Finds every patient overdue for an annual or vaccine, drafts a warm, species-specific outreach, and routes it to the channel the client prefers (text, email, postcard).
### Rx refill reminders
Tracks every active prescription, predicts the refill date, and nudges the client 7 days out with a one-tap reorder link. Reduces compliance gaps and front-desk call volume in one move.
### Wellness plan recommender
Identifies clients already spending enough that a plan would break even, and drafts the conversation for your front desk, personalized to the pet's care history and your in-house plan.
### New-puppy + new-kitten onboarding
A 12-week onboarding sequence per new patient: vaccine schedule, training tips, food guidance, and check-in reminders, all branded as your practice.
### Review monitor + board-compliant reply
Catches every Google, Facebook, and Nextdoor review the moment it lands and drafts an empathetic reply that respects client confidentiality under your state's veterinary practice act. Your practice owner approves with one tap.
## A day-one prompt
> Pull every patient who hasn't been in for 14+ months, group by species and last visit reason, and draft a warm reactivation message per group. Hold them in drafts for me. I want to review tone before any of these go out.
## FAQ
### Does Duet integrate with my PIMS (AVImark, Cornerstone, ezyVet, Pulse, Provet Cloud, Shepherd, Vetspire, Digitail)?
Yes. Duet reads and writes through your PIMS API where one exists, and through a structured export or reminder workflow where it doesn't. Your PIMS stays the system of record.
### HIPAA, vet boards, and client privacy: what actually applies?
HIPAA does not apply to veterinary practices. It covers human protected health info, and animals are not 'persons' under the statute. What does apply: your state's veterinary practice act, the AVMA Principles of Veterinary Medical Ethics, state breach-notification laws for owner PII, and PCI-DSS if you store card data. Duet drafts every public-facing reply to comply: no patient details, no diagnoses, no records exposure.
### Will Duet practice medicine?
No. Duet drafts. Your DVM decides. Anything clinical (triage, refill approval, treatment plan) is held as a draft for a licensed clinician to approve before it goes to the client.
### How does it compare to PetDesk (now including Vetstoria), Weave, Otto, and Digitail?
Those are bookable reminder and messaging tools, narrow and single-purpose. Duet is broader: reactivation, no-show recovery, wellness-plan candidates, refill nudges, onboarding sequences, and review replies all from one workspace, written in your voice instead of a templated script.
### How long does setup take?
Most practices are live on their first workflow (usually no-show recovery or lapsed-client reactivation) within a week. The full playbook lands inside the first month.
### Can I start with one workflow?
Yes. Most independents start with either no-show recovery or lapsed-client reactivation, the two workflows that pay back fastest.
---
Source: https://duet.so/guides
# Guides for running your business with AI
Step-by-step playbooks for Claude Code, MCP, agent skills, and agentic workflows — from first setup to running every function of your business through one AI hire.
## Guides
- [The 10 Best AI Agent Platforms for Developers in 2026 — Ranked by Fit](https://duet.so/guides/best-ai-agent-platforms-2026.md): The 10 best AI coding agent platforms compared — Cursor, Devin, Claude Code, Duet, v0, and more. Ranked by fit for solo devs, teams, and enterprises.
- [The 10 Steps of AI Transformation: Why Only 1 of Them Is Actually AI](https://duet.so/guides/ai-transformation-10-steps.md): AI transformation is 9 parts process, 1 part AI. The 10-step playbook for making any workflow AI-native — and where most teams quietly get stuck.
- [Claude Code Memory: Complete Guide to Making Claude Remember Everything](https://duet.so/guides/claude-code-memory.md): Set up Claude Code memory with CLAUDE.md files. Persistent instructions, project conventions, and team-shared context across sessions.
- [The $47,000 Claude Code Bill (and How Smart Model Routing Prevents It)](https://duet.so/guides/claude-opus-vs-sonnet-model-routing.md): Developers have burned $47K in days on Claude Code. Learn model routing with Opus, Sonnet, and Haiku to cut your AI bill by 50-70%.
- [Claude Code MCP Servers: Complete Setup Guide (2026)](https://duet.so/guides/claude-code-mcp-servers-setup.md): Claude Code MCP servers connect your AI agent to GitHub, Slack, Notion, databases, and more. Step-by-step setup, configuration, and the best MCP servers for coding workflows.
- [How to Set Up Duet: A Founder Walkthrough for Your AI Workforce](https://duet.so/guides/how-to-set-up-duet.md): How to set up Duet for a real first job: start a durable session, organize files, train reusable context, connect integrations, and ship apps.
- [Claude Code for Teams: The Complete Setup Guide for 2026](https://duet.so/guides/claude-code-for-teams.md): The deployment runbook for rolling out Claude Code across a team — plan structure, shared CLAUDE.md, Skills, MCP, Subagents, onboarding, and measuring ROI. Plus the five rollout mistakes to avoid.
- [AI Amnesia: Why Your AI Keeps Forgetting (and How to Actually Fix It)](https://duet.so/guides/ai-amnesia-why-your-ai-keeps-forgetting.md): The 5 real reasons Claude, ChatGPT, Codex, Claude Code and OpenClaw lose your context — compaction, new chat amnesia, lost-in-the-middle, memory full, and patch wipes — with real fixes.
- [Claude Code Skills: The Complete Guide (2026)](https://duet.so/guides/claude-code-skills-complete-guide.md): Everything you need to know about Claude Code Skills — what they are, how SKILL.md works, when to use Skills vs MCP vs Subagents, how to build your first skill, and how to share them across a team.
- [Duet AI for Founders: Founder Mode as an Operating System](https://duet.so/guides/duet-ai-for-founders.md): Duet AI turns Founder Mode into an operating system. Run a 3-person company like a 50-person one. Ship faster. Skip middle management. Stay close to the product.
- [How to Build Your AI Command Center with Duet](https://duet.so/guides/how-to-build-your-ai-command-center.md): Stop juggling scattered AI tools. Build a centralized AI command center in minutes — one place for your integrations, knowledge base, automations, and custom apps.
- [How to Set Up OpenClaw for Your Team](https://duet.so/guides/how-to-set-up-openclaw-for-your-team.md): Set up OpenClaw for your team: cloud hosting, auth, permissions, and uptime. Compare $10K+ in DIY labor with Duet monthly plans.
- [ACORD Forms and Commercial Quote Prep with AI](https://duet.so/guides/acord-forms-commercial-quote-prep-with-ai.md): Use AI to turn scattered intake documents into clean, submission-ready ACORD packets with fewer rework loops.
- [Client Emails and Renewal Follow-Ups Faster with AI](https://duet.so/guides/client-emails-renewal-follow-ups-faster-with-ai.md): Speed up client emails and renewal follow-ups with an AI drafting system that keeps communication consistent.
- [How to Cut Rekeying in Carrier Portals with AI](https://duet.so/guides/how-to-cut-rekeying-in-carrier-portals.md): Reduce carrier portal rekeying with AI that extracts ACORD data and powers automated carrier submissions across portals.
- [A Practical Guide to AI for Independent Insurance Agents](https://duet.so/guides/ai-insurance-agent-productivity.md): The 5 tasks where AI saves the most time, what not to put into AI tools, and a 30-minute action plan. Practical workflows for independent agents.
- [Claude Code vs Claude Cowork Comparison](https://duet.so/guides/claude-code-vs-claude-cowork.md): Compare Claude Code and Claude Cowork — what each does best, key differences, and when to use which for your workflow.
- [Claude Cowork: Complete Beginner's Guide](https://duet.so/guides/claude-cowork-for-beginners.md): Learn Claude Cowork from scratch. Setup, context files, plugins, connectors, scheduled tasks, and practical workflows for non-technical users.
- [Duet vs Claude Code: Cloud Agent vs CLI](https://duet.so/guides/duet-vs-claude-code.md): Compare Duet and Claude Code: solo CLI vs cloud dev environment with a persistent always-on agent.
- [Duet vs OpenAI Codex: Cloud IDE vs Agent (2026)](https://duet.so/guides/duet-vs-codex.md): Compare Duet and OpenAI Codex for AI agent workflows. Codex is a multi-agent coding tool; Duet is a cloud dev environment with a persistent always-on agent.
- [Duet vs Conductor: Which AI Agent Platform is Better?](https://duet.so/guides/duet-vs-conductor.md): An honest comparison of Duet and Conductor. Local Mac execution vs cloud dev environments. See which AI agent runner is right for your team.
- [Duet vs OpenClaw: Cloud IDE vs Personal AI (2026)](https://duet.so/guides/duet-vs-openclaw.md): Compare Duet and OpenClaw for AI agent workflows. Duet is a cloud dev environment with managed integrations; OpenClaw is a self-hosted personal AI.
- [AI Search Discovery: An Ethical Playbook for Getting Cited](https://duet.so/guides/ai-search-discovery-ethical-playbook.md): How to get your content cited by ChatGPT, Perplexity, and Google AI Overviews using structured data, answerable formatting, and ethical authority building.
- [How to Build a Shared AI Skill Library for Claude Code](https://duet.so/guides/beyond-claude-code-building-a-shared-skill-library.md): Stop copy-pasting prompts. Learn how to build, share, and maintain an AI agent skill library across Claude.ai, Claude Code, and your entire team.
- [The Claude Code Playbook: Skill-First Workflows](https://duet.so/guides/claude-code-playbook-building-a-skill-first-workflow-that-actually-sticks.md): Build skill-first workflows with Claude Code that stick. CLAUDE.md, commands, skills, and the Explore-Plan-Execute-Verify loop. No coding required.
- [Skills vs MCP: What's the Difference and When to Use Each](https://duet.so/guides/agent-skills-101-tools-vs-mcp-vs-skills.md): Skills teach AI agents how to work. MCP connects them to external data. Here's exactly when to use Tools, MCP, or Skills in your agent workflows.
- [Claude Code for Business & Founders: Automate GTM & Ops](https://duet.so/guides/claude-code-for-founders.md): Replace your $5k/mo automation stack. Learn how non-technical founders use Claude Code to automate marketing, product, and operations workflows.
---
Source: https://duet.so/guides/acord-forms-commercial-quote-prep-with-ai
# ACORD Forms and Commercial Quote Prep with AI
*Use AI to turn scattered intake documents into clean, submission-ready ACORD packets with fewer rework loops.*
By Duet Team. Published 2026-03-09, updated 2026-05-08. 7 min read.
# How to Automate ACORD Forms and Commercial Quote Prep with AI
Quick Summary
This guide covers how insurance agents can use AI to speed up ACORD form completion and commercial quote preparation. Automating data population and reducing the manual back-and-forth that slows commercial submissions.
Questions this page answers
- How to use AI for ACORD forms
- AI tools for commercial insurance quote preparation
- How to automate ACORD form completion
- Can AI fill out commercial insurance forms?
- How to speed up commercial quote prep with AI
It's 4:47 PM and you're staring at the same submission file you opened right after lunch.
The account seems impossible. Because the prep is endless.
A loss run that should have been "quick" turned into twenty pages. The ACORD is half complete. The supplemental questions are buried in an email thread. The client's answers are close, but not quite usable. And you're still not sure whether the payroll figure you have is current or from last year.
This is the part of commercial lines that quietly eats agencies alive.
The actual quoting, the judgment, the market strategy, the carrier relationships — all that is high-value work.
But the hours disappear before you even get there: collecting fields, validating completeness, structuring a clean submission, and making sure nothing gets missed.
That prep layer is where an AI-assisted workflow helps most. Not by "doing the quote," but by turning scattered documents into an organized, reviewable packet — faster, and with fewer rework loops.
Primary next step: See the ACORD + quote prep landing page
---
## Why ACORD Form Completion and Commercial Quote Prep Is So Slow
Commercial submissions tend to move slowly for reasons that have nothing to do with carrier appetite or underwriting speed. The drag usually happens earlier. In the preparation layer.
A typical quote prep cycle includes:
| Collect | Clarify | Standardize | Follow up |
| ------------------------------------------------------------------------- | -------------------------------------------------- | --------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| Back-and-forth to collect missing information and resolve inconsistencies | Clarifying ACORD fields and supplemental questions | Standardizing documents into a carrier-ready submission package | Repeating the same follow-ups, reminders, and status updates across accounts |
When there is no consistent structure, each new submission becomes a one-off project. Teams end up rebuilding the same checklist, re-reading the same document types, and reformatting the same information from scratch — even when the risks are similar.
---
## AI Workflow for Faster ACORD Form Completion
The goal is not to "automate quoting." It is to reduce the prep work that makes commercial submissions slow and error-prone.
A practical workflow looks like this:
### Normalize Client Intake Into an ACORD-Style Checklist
Start by converting whatever information you received — broker notes, insured emails, prior applications, schedules, PDFs — into one structured intake checklist that mirrors how you think about an ACORD and carrier supplements.
This checklist should separate:
- Core account details (named insured, locations, operations)
- Exposure details (payroll, receipts, vehicles, property, etc.)
- Prior insurance and loss history
- Requested coverages and limits
- Open questions that still need answers
### Use AI to Flag Missing Fields Before Carrier Submission
Before anyone starts packaging the submission, run a "missing field" pass.
The objective is to catch gaps early — not halfway through a carrier portal or after an underwriter asks for clarifications. This is where a lot of preventable rework comes from.
### Generate a Submission-Ready Commercial Quote Brief
Next, create a clean summary that can travel with the submission and stay consistent across carriers.
A strong quote brief typically includes:
- A one-page risk overview
- Key exposure numbers and assumptions
- Loss run summary highlights
- Special considerations / underwriting notes
- Required attachments and what is still pending
This becomes your internal anchor so the story stays consistent across markets.
### Orchestrate Follow-Ups and Track Ownership With AI
Finally, turn the same packet into a simple follow-up plan:
- What is pending
- Who owns each item (client, CSR, producer, broker)
- The deadline or target date
- The next message to send (client, underwriter, internal)
This reduces the "where are we on this?" churn that drags submissions out for days.
Use-case page: ACORD + quote prep workflow
---
## AI Prompt Starter: ACORD Forms and Commercial Submissions
> Using this intake text, generate: (1) ACORD field checklist, (2) missing information list with priority, (3) carrier submission brief, (4) follow-up email draft.
---
## Compliance and Quality Controls for AI-Assisted ACORD Form Completion
AI can make commercial quote prep faster, but only if you keep clear guardrails around privacy, accuracy, and judgment.
A few controls matter most:
Avoid sharing information that could directly identify an insured or a claim file unless your
agency has approved the tool and data-handling terms for that use case.
Supplements, required attachments, and field expectations vary by carrier and class. Treat AI
output as a starting point, not a source of truth.
The decision of what to submit, how to frame the risk, and what assumptions to make belongs with
licensed professionals and experienced account teams.
The right mental model is simple. AI should reduce prep friction and improve consistency — not replace underwriting judgment.
---
## Metrics That Prove the ROI of AI for Commercial Quote Prep
| Metric | What it measures |
| ----------------------------------------------------- | ------------------------------------------------------------------ |
| Commercial quotes processed per week | Overall throughput improvement as prep time decreases |
| Time from intake to submission-ready package | How quickly your team can go from raw intake to a clean submission |
| Percentage of submissions returned for missing fields | Whether gap detection is catching issues before carriers flag them |
---
## Related Resources
- ACORD + quote prep use-case page
- Insurance segment landing page
---
## Ready to Speed Up Your Commercial Submissions?
If quote prep is your bottleneck, this is the fastest workflow to standardize.
---
## Frequently Asked Questions
### What are ACORD forms and why are they used in insurance?
ACORD forms are standardised insurance application and data exchange forms used across the industry. They provide a common format so agents, carriers, and MGAs can exchange risk information consistently. Most commercial lines submissions require one or more ACORD forms - the most common being ACORD 125 and ACORD 126.
### How can AI speed up ACORD form completion?
AI can extract information from a client's existing documents and pre-populate ACORD form fields automatically. It can also flag missing required fields and format outputs for carrier upload. This reduces manual entry time from 30-60 minutes per submission to a fraction of that.
### Can AI handle complex commercial submissions, not just simple ones?
AI handles straightforward data extraction and form-filling well for most commercial lines. For highly complex risks - large construction projects, specialty coverages, unique exposures - AI assists with data organisation and documentation, but underwriting judgment remains a human responsibility.
### What data does AI need to fill out ACORD forms accurately?
The more structured the input, the better the output. Ideal inputs are completed client questionnaires, prior policy declarations pages, and business registration information. Clear, complete source documents produce the most reliable ACORD pre-fills.
### Are there specific AI tools built for ACORD form automation?
Several insurtech platforms offer ACORD-specific AI tools. General-purpose AI agents (like those on Duet) can also be configured to handle ACORD workflows. The choice depends on your submission volume - purpose-built tools may be worth the cost for high-volume agencies.
### Does using AI for ACORD forms create any E&O exposure?
The risk is the same as any data entry error. If incorrect information is submitted and coverage is bound based on that information, there could be E&O implications. The mitigation is always having a licensed agent review AI-completed forms before submission.
---
Source: https://duet.so/guides/agent-skills-101-tools-vs-mcp-vs-skills
# Skills vs MCP: What's the Difference and When to Use Each
*Skills teach AI agents how to work. MCP connects them to external data. Here's exactly when to use Tools, MCP, or Skills in your agent workflows.*
By Sawyer Middeleer. Published 2026-02-02, updated 2026-05-08. 19 min read.
Confused by AI agent terminology? This guide breaks down the exact difference between **Tools**, **MCP (Model Context Protocol)**, and **Agent Skills** — so you can build smarter AI workflows today. By the end, you'll know exactly when to use each one, and how they fit together.
**Quick Summary**
In AI agents, Tools are individual callable functions (search, calculator), MCP (Model Context Protocol) is Anthropic's open standard for connecting agents to external services, and Agent Skills are reusable pre-packaged workflows combining multiple tools. Use Tools for custom tasks, MCP for standardized integrations, Skills for repeatable workflows.
If you're brand new to Claude Code itself, start with [the beginner's guide](/guides/claude-code-for-founders) and then come back here for the deeper tools/MCP/skills architecture.
## Tools vs MCP vs Agent Skills: Quick Comparison
| Feature | Tools | MCP (Model Context Protocol) | Agent Skills |
| -------------- | -------------------------------------------------- | --------------------------------------------------------------- | -------------------------------------------------------------- |
| What it is | Functions an AI can call (e.g. search, calculator) | A protocol for connecting AI to external data sources and tools | Pre-built, reusable agent capabilities packaged for deployment |
| Who defines it | Developer | Anthropic (open standard) | Platform / marketplace |
| Best for | Custom one-off integrations | Standardized multi-tool connections | Repeatable workflows across projects |
| Complexity | Low | Medium | Low (plug-and-play) |
| Example | Web search, code execution | GitHub MCP, Slack MCP | "Research & summarize" skill |
---
## TL;DR: The Three Primitives
| Primitive | What It Does | When to Use It |
| ---------- | --------------------------------------------------------------- | ---------------------------------------------------------- |
| **Tools** | Execute single actions (fetch file, create ticket, run command) | You need one discrete operation |
| **MCP** | Standardized protocol connecting AI to external systems | You need reliable access to Slack, GitHub, databases, etc. |
| **Skills** | Packaged workflows with instructions + resources + checks | You need repeatable, consistent results across runs |
**The key insight:** Tools do actions. MCP provides access. Skills encode _how to do the job right_—and because they're files the agent can read and write, they're self-improving.
---
## What Are Tools?
AI agent tools are individual functions an AI model can call — like web search, file reading, database queries, or API calls. Each tool does one discrete action with one input and one output. Tools are the building blocks of any agent, but they don't encode multi-step workflows or quality standards on their own.
A tool is a single operation the agent can execute. Think "one step," not "a workflow."
### Examples of Tools
- `read_file` — fetch contents of a file
- `create_jira_ticket` — create a ticket with given parameters
- `run_bash_command` — execute a shell command
- `search_codebase` — find files matching a pattern
- `send_slack_message` — post to a channel
### What Tools Are Good At
**Precision**: One input → one output. Easy to test and debug.
**Control**: You know exactly what happened. No ambiguity.
**Composability**: Tools can be chained. But _you_ still need to define the chain.
### Where Tools Break Down
Tools don't encode _how to do the job end-to-end_. If you rely on tools + prompts alone:
- Sequencing varies ("sometimes it summarizes first, sometimes writes first")
- No definition of done ("is this actually complete?")
- Instructions repeat ("use our format, not that format" — every single time)
**Tools answer:** "What can I do?"
**They don't answer:** "What should I do, in what order, with what quality bar?"
---
## What Is MCP (Model Context Protocol)?
MCP (Model Context Protocol) is an open standard by Anthropic that defines how AI models connect to external tools, databases, and APIs. Instead of building custom integrations for every service, MCP provides a universal connector using JSON-RPC 2.0. It supports local (stdio) and remote (HTTP) transports.
MCP is an open protocol introduced by Anthropic in November 2024. It standardizes how AI applications connect to external systems.
**The problem it solves:** Without MCP, every integration is a custom one-off. Connect Claude to Slack? Custom code. Connect to GitHub? Different custom code. Connect to your database? Yet another integration.
MCP defines a consistent client/server protocol so you build the integration once, and any MCP-compatible AI can use it.
### How MCP Works (Technical)
MCP uses **JSON-RPC 2.0** for message encoding. All communication happens through three message types:
```
Request: { "jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {} }
Response: { "jsonrpc": "2.0", "id": 1, "result": { "tools": [...] } }
Notification: { "jsonrpc": "2.0", "method": "progress", "params": { "percent": 50 } }
```
### MCP Architecture
- **Host**: The AI application (Claude Desktop, your app)
- **Client**: Connector within the host that talks to one server
- **Server**: Service exposing tools, resources, or prompts
### Transport Options
**1. stdio (Local)**
Client spawns server as subprocess. Messages flow through stdin/stdout.
```bash
# Server reads from stdin, writes to stdout
[Client] → stdin → [Server Process] → stdout → [Client]
```
Best for: Local integrations, single-client scenarios, CLI tools.
**2. Streamable HTTP (Remote)**
Server runs independently. Clients connect via HTTP POST.
```bash
curl -X POST https://mcp-server.example.com/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-H "Mcp-Session-Id: abc123" \
-d '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", ...}'
```
Best for: Remote servers, multi-client scenarios, team deployments.
### What MCP Servers Expose
- **Resources**: Data the AI can read (files, database records, API responses)
- **Tools**: Actions the AI can execute (create ticket, send message, run query)
- **Prompts**: Pre-built templates for common workflows
### Where MCP Stops
MCP gives you **access**, not **method**.
It tells you: "Here's how to connect to Slack and what you can do there."
It doesn't tell you: "When writing a status update, pull from these three channels, summarize in this format, and get approval before posting."
That's what Skills are for.
For a step-by-step walkthrough of using MCP tools inside Claude Code, see [Section 6: MCP Tools in the Claude Code Beginner's Guide](/guides/claude-code-for-founders#6-mcp-tools).
---
## What Are Skills?
Agent Skills are pre-built, reusable packages of agent behavior that combine instructions, templates, and quality checks into a single capability. Unlike individual tools, a skill encodes the full "how" — step-by-step workflow, output format, and definition of done. Skills use progressive disclosure to load only what's needed, avoiding context bloat.
Skills are reusable workflows that bundle procedural knowledge and assets. They tell the agent _how_ to do a job consistently.
Anthropic's analogy: Building a skill is like assembling an onboarding guide for a new hire. You're capturing procedural knowledge so the agent doesn't reinvent the process every time.
### Skill = Method + Resources + Checks
A useful mental model:
| Component | What It Contains | Example |
| ------------- | ------------------------------ | --------------------------------------------------------------- |
| **Metadata** | Name, description, when to use | "Use when creating PRDs from meeting notes" |
| **Method** | Step-by-step workflow | "1. Extract decisions 2. Identify owners 3. Format as template" |
| **Resources** | Templates, examples, schemas | `prd-template.md`, `example-prd.md` |
| **Checks** | Definition of done, guardrails | "Must have owner for each action item" |
### Why Skills Don't Bloat Context
**Progressive disclosure**: Skills use a three-level loading model.
| Level | When Loaded | Token Cost | Content |
| --------------------- | ----------- | ------------- | ---------------------------- |
| Level 1: Metadata | Always | ~100 tokens | Name + description |
| Level 2: Instructions | On trigger | <5k tokens | Full SKILL.md body |
| Level 3: Resources | As needed | Unlimited | Templates, scripts, examples |
The agent starts with just the description. Full instructions load only when the skill activates. Resource files load only when referenced.
This means you can package extensive institutional knowledge (templates, examples, playbooks) without paying the context cost until it's actually needed.
### Pre-Built Skills from Anthropic
Anthropic ships pre-built Agent Skills for common document workflows:
| Skill | What It Does |
| -------- | ---------------------------------------- |
| **pptx** | Create and edit PowerPoint presentations |
| **xlsx** | Create and analyze Excel spreadsheets |
| **docx** | Create and edit Word documents |
| **pdf** | Generate PDF documents |
These run in a code execution environment with filesystem access. They're the difference between the LLM returning "here's what your slides should say" and actually producing a `.pptx` file you can open.
---
## Skills in Claude Code
Claude Code has its own skill system that's filesystem-based and project-local.
If you want a higher-level tour of skills inside the product before diving into directory structure, check out [Section 7: Skills in the Claude Code Beginner's Guide](/guides/claude-code-for-founders#7-skills).
### Skill Directory Structure
### SKILL.md Format
```yaml
---
name: code-review
description: Reviews code for security issues and best practices. Use when reviewing PRs or commits.
allowed-tools: Read, Grep, Glob
---
# Code Review
When reviewing code:
1. **Security scan**: Check for injection vulnerabilities, exposed secrets, unsafe deserialization
2. **Style check**: Verify naming conventions, file organization, comment quality
3. **Logic review**: Trace data flow, identify edge cases, check error handling
4. **Output format**: Use the template in review-template.md
## Common issues to flag
- SQL queries built with string concatenation
- User input passed directly to shell commands
- Missing input validation on API endpoints
- Hardcoded credentials or API keys
```
### Frontmatter Options
| Field | Purpose | Default |
| -------------------------- | --------------------------------------------- | --------------- |
| `name` | Display name (lowercase, hyphens) | Directory name |
| `description` | When to use (Claude uses for auto-invocation) | First paragraph |
| `allowed-tools` | Restrict available tools | All tools |
| `disable-model-invocation` | Prevent auto-use (manual `/name` only) | false |
| `user-invocable` | Hide from `/` menu if false | true |
| `context` | `inline` or `fork` (isolated subagent) | inline |
### Invocation Modes
**Default**: User invokes with `/skill-name`, Claude auto-invokes when relevant.
**Manual only** (`disable-model-invocation: true`): User must type `/skill-name`. Claude won't auto-trigger.
**Claude only** (`user-invocable: false`): Claude auto-invokes when relevant. Not shown in menu.
### Dynamic Content
Skills support variable substitution:
```yaml
---
name: session-logger
---
Log activity to: logs/${CLAUDE_SESSION_ID}.log
User request: $ARGUMENTS
```
And shell command injection (output replaces placeholder):
```yaml
---
name: pr-summary
---
## PR Context
Diff: !`gh pr diff`
Comments: !`gh pr view --comments`
Summarize this PR...
```
---
## Real-World Use Cases
These examples pair well with the chat modes and scope-plan-execute workflow described in [Working With Claude Code](/guides/claude-code-for-founders#3-working-with-claude-code) and the [Chat Modes section](/guides/claude-code-for-founders#chat-modes). For more business-focused examples, see [How to Run Your Entire Business with Claude Code](/guides/claude-code-for-founders).
### Use Case 1: Automated Code Review
**Without skills**: Every code review is different. Sometimes the agent checks security, sometimes style, sometimes neither. Output format varies.
**With skills**:
```yaml
---
name: security-review
description: Security-focused code review. Use when reviewing PRs touching auth, payments, or user data.
allowed-tools: Read, Grep, Glob
---
# Security Review
## Checklist
1. [ ] No SQL injection (parameterized queries only)
2. [ ] No command injection (no shell calls with user input)
3. [ ] No exposed secrets (check for hardcoded keys)
4. [ ] Input validation on all external data
5. [ ] Proper authentication checks
## Output format
Use severity levels: CRITICAL, HIGH, MEDIUM, LOW
For each finding:
- File and line number
- Description of issue
- Suggested fix
```
**Result**: Every security review follows the same checklist. Output is consistent. Nothing gets missed.
### Use Case 2: Meeting Notes → Action Items
**The problem**: Converting meeting transcripts to action items is tedious and inconsistent.
**The skill**:
```yaml
---
name: meeting-processor
description: Convert meeting notes to decisions and action items. Use after meetings.
---
# Meeting Processor
## Steps
1. Extract all decisions made (statements of agreement or conclusion)
2. Extract all action items (tasks assigned to people)
3. Identify open questions (unresolved discussions)
4. Format using action-template.md
## Action item format
Each action item MUST have:
- Clear description (what, not how)
- Owner (single person responsible)
- Due date (if mentioned)
## Quality check
- Every action item has an owner
- No vague items ("follow up on X" → "John to send X proposal to team by Friday")
```
### Use Case 3: Documentation from Code
**The skill**:
```yaml
---
name: api-docs
description: Generate API documentation from code. Use when documenting endpoints.
allowed-tools: Read, Grep, Glob
---
# API Documentation Generator
## Process
1. Find all route definitions (Grep for route patterns)
2. For each endpoint, extract:
- HTTP method and path
- Request parameters and body schema
- Response format
- Authentication requirements
3. Generate markdown using api-doc-template.md
## Include for each endpoint
- Description (what it does, not how)
- Request example (curl command)
- Response example (actual JSON)
- Error cases (4xx/5xx responses)
```
---
## How Tools, MCP, and Skills Work Together
Tools, MCP, and Skills form a layered architecture: Skills define the workflow and quality bar, MCP provides standardized access to external services, and Tools execute individual actions. A typical flow: a Skill triggers, loads its instructions, connects via MCP to external data, executes Tools for each step, then validates the output.
**Example flow**:
1. **Skill triggers**: User asks to "create a weekly status update"
2. **Skill loads**: Instructions say "pull from #engineering, #product, summarize blockers"
3. **MCP connects**: Slack MCP server provides access to channels
4. **Tools execute**: `read_channel`, `search_messages`, `post_message`
5. **Skill validates**: Check output matches template, has all required sections
---
## Looking Ahead
As skills mature, the boundary between skills and tools will blur. Skills live on the filesystem and can contain executable code—meaning they can perform the same actions tools do, with two key advantages: **agents can read skills to understand them**, and **write to them to self-improve**.
The likely trajectory: tools and MCP become thin primitives (read/write, fetch, search), while skills absorb the domain-specific logic.
---
## When to Use What
### Use Tools When:
- You need a single, discrete operation
- The action is self-contained (no workflow)
- You're building blocks for higher-level automation
### Use MCP When:
- You need to connect to external systems (Slack, GitHub, databases)
- You want integrations that work across AI platforms
- You're building server-based infrastructure
### Use Skills When:
- You need consistent, repeatable results
- The task requires multiple steps in a specific order
- You want to capture institutional knowledge
- Output quality matters (templates, checks, examples)
### Decision Tree
---
## Common Mistakes
### Mistake 1: Using Prompts Instead of Skills
**Problem**: Pasting the same instructions into every conversation.
**Solution**: Package it as a skill. Write once, use consistently. See [The Claude Code Playbook](/guides/claude-code-playbook-building-a-skill-first-workflow-that-actually-sticks#skills-giving-claude-deep-expertise) for a practical walkthrough.
### Mistake 2: Stuffing Everything into MCP
**Problem**: Building complex workflows into MCP servers.
**Solution**: MCP handles access. Skills handle workflow. Keep them separate.
### Mistake 3: No Definition of Done
**Problem**: Agent produces output, but you don't know if it's complete.
**Solution**: Add checks to your skill. "Every action item must have an owner."
### Mistake 4: Ignoring Progressive Disclosure
**Problem**: Loading all context upfront, blowing up the context window.
**Solution**: Use the three-level model. Metadata always. Instructions on trigger. Resources on demand.
---
## Security Considerations
### MCP Security
- Validate `Origin` header on HTTP transports (prevent DNS rebinding)
- Bind to localhost only for local servers (not 0.0.0.0)
- Require explicit user consent for tool invocation
- Implement proper authentication for remote servers
### Skill Security
- Use `allowed-tools` to restrict what a skill can do
- Set `disable-model-invocation: true` for sensitive operations
- Audit skills from external sources before use
- Skills can include executable code—treat them like dependencies
---
## Quick Reference
### MCP Message Format
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "search_code",
"arguments": { "query": "authentication" }
}
}
```
### Skill File Structure
```
.claude/skills/my-skill/
├── SKILL.md # Instructions (required)
├── template.md # Output template
├── examples/ # Example outputs
└── scripts/ # Validation scripts
```
### Skill Frontmatter
```yaml
---
name: skill-name
description: When to use this skill
allowed-tools: Read, Grep, Glob
disable-model-invocation: false
user-invocable: true
---
```
---
## Further Reading
- [Beyond Claude Code: Building a Shared Skill Library](/guides/beyond-claude-code-building-a-shared-skill-library) — How to build, share, and maintain skills across Claude.ai, the API, and Agent SDK
- [MCP Specification](https://modelcontextprotocol.io/specification/2025-11-25) — Full protocol documentation
- [Claude Code Skills Docs](https://docs.anthropic.com/en/docs/claude-code/skills) — Official skill documentation
- [Anthropic Skills Repository](https://github.com/anthropics/skills) — Pre-built skills and examples
- [MCP GitHub](https://github.com/modelcontextprotocol) — Protocol implementation and servers
---
## Frequently Asked Questions
**What is the difference between AI Tools and Agent Skills?**
AI Tools are individual functions an agent can call (like web search or a calculator). Agent
Skills are pre-packaged, reusable workflows that combine multiple tools into a single capability
— like a "research and summarize" skill that uses search, reading, and writing tools together.
**What is MCP (Model Context Protocol) and why does it matter?**
MCP (Model Context Protocol) is an open standard created by Anthropic that defines how AI models
connect to external tools, databases, and APIs. It matters because it eliminates the need to
build custom integrations for every service — instead, you use one standardized protocol to
connect your AI agent to any MCP-compatible service.
**What are Agent Skills?**
Agent Skills are **reusable abilities** you give an AI agent so it can do a job the same way every time. Instead of writing a fresh prompt for every task, a skill packages the "how" once (steps + templates + rules) and Claude can use it when needed.
Anthropic's docs describe pre-built Skills and state Claude can automatically use them when relevant.
**Are skills just prompts?**
No. A prompt is usually a one-time instruction. A skill is more like a mini playbook (and
sometimes includes scripts + files) that the agent can reuse. Anthropic describes skills as
folders that can include instructions, scripts, and resources that Claude loads when needed.
**What's the difference between a tool and a skill?**
- A tool does one action (example: "create a Jira ticket," "search docs," "run a command"). - A
skill is a full workflow (example: "turn a meeting into decisions + action items + follow-ups")
and it can use multiple tools along the way.
**What is MCP in simple terms?**
MCP (Model Context Protocol) is a standard way for an AI agent to connect to your tools and data
(like Slack, Drive, GitHub, Jira, etc.). It uses a known message format (JSON-RPC) and has
standard ways to connect (like stdio or HTTP).
**Do I need MCP to use skills?**
Not always. You need **MCP** when the workflow must pull from or act inside external systems
(like reading a doc from Drive or posting to Slack). If the skill is mostly about producing a
clean output (like a doc/deck/spreadsheet) from what you already provide, you can use skills
without MCP.
**What does "progressive disclosure" mean?**
It means the agent doesn't load everything upfront. It starts with a small description of the
skill, and only loads the detailed instructions/templates when it actually needs them. This
keeps the conversation lighter and avoids huge context dumps.
**What pre-built skills exist today (in Claude)?**
Anthropic's docs list pre-built skills for common work outputs:
- **pptx** (PowerPoint)
- **xlsx** (Excel)
- **docx** (Word)
- **pdf**
**Can Claude Code subagents use MCP tools?**
Yes. Claude Code's docs say subagents inherit the same tools as the main session, including MCP
tools by default (and you can restrict them if needed).
**Will skills replace tools and MCP?**
Partially. Skills can contain executable code, so they can do what tools do—with the advantage
that agents can read skills to understand them and modify them to improve. The likely future:
tools/MCP become primitives (filesystem, web, shell), while skills absorb everything
domain-specific.
## Keep reading
- [Duet AI for Founders: Founder Mode as an Operating System](/guides/duet-ai-for-founders). Stack reusable playbooks, Train context, and durable sessions for founder-led teams.
- [Claude Code for Business](/guides/claude-code-for-founders) — automate GTM, product, and ops with Claude Code.
- [Building a Shared Skill Library](/guides/beyond-claude-code-building-a-shared-skill-library) — go deeper on creating and sharing reusable skills.
- [MCP Alternatives for Code Execution Agents](/blog/mcp-alternatives-code-execution-agents) — explore alternatives beyond MCP for agent tooling.
- [How to Build and Deploy a Web App Using Only AI](/blog/how-to-build-and-deploy-a-web-app-using-only-ai) — see skills and tools in action.
---
Source: https://duet.so/guides/ai-amnesia-why-your-ai-keeps-forgetting
# AI Amnesia: Why Your AI Keeps Forgetting (and How to Actually Fix It)
*The 5 real reasons Claude, ChatGPT, Codex, Claude Code and OpenClaw lose your context — compaction, new chat amnesia, lost-in-the-middle, memory full, and patch wipes — with real fixes.*
By Duet Team. Published 2026-05-15, updated 2026-05-15. 18 min read.
Every serious AI user hits the same wall. You spend an hour explaining context, building rapport, fine-tuning instructions. The model is finally useful. Then it forgets. You open a new chat tomorrow and it has the **"first day at work"** energy all over again. People on Reddit have a word for this: **AI amnesia.**
It is not your imagination, and it is not one bug. It is five different failure modes wearing the same costume. This guide walks through each one — using the exact language real users are typing into r/ClaudeAI, r/ChatGPT, r/codex, and r/openclaw — and shows what actually fixes it.
**Why does my AI keep forgetting things?**
AI tools forget for five distinct reasons: context compaction discarding decisions, new-session amnesia between chats, mid-thread degradation ('lost in the middle'), silent memory deletion when the memory store fills up, and patch wipes that erase chat history on update.
---
## 1. What "AI amnesia" actually means
Strictly speaking, large language models do not have memory. They have a **context window** — a fixed amount of recent text the model can read at once — and whatever scaffolding the product wraps around it. Everything that feels like "memory" is one of three things:
- The current context window (resets on close)
- A summary or compacted version of past turns
- A separate memory store (system instructions, profile facts, saved chats) injected back into context on each turn
When users say their AI has amnesia, they usually mean one of those three things broke. The five reasons below map to specific failure modes in real products.
A quick taste of the vocabulary users have invented for it:
| Term | Meaning |
| ---------------------- | ------------------------------------------------------------------------ |
| **Amnesia** | The umbrella complaint. Used as a noun: "Claude amnesia," "GPT amnesia." |
| **Goldfish memory** | Mocking, general. "AI with the memory of a goldfish." |
| **Compaction** | Anthropic's actual feature name; now slang for any forced summarization. |
| **New chat amnesia** | Opening a new conversation and watching it forget you exist. |
| **Lost in the middle** | Models ignoring info buried in the middle of a long context. |
| **Memory Full** | ChatGPT's notification when the memory store is at capacity. |
| **Context anxiety** | The dread of approaching the window limit on a long task. |
Memory is the highest-leverage feature in any AI tool. Without it, every productive session is
throwaway work. The fix is rarely "switch models" — it is changing where the memory lives.
---
## 2. Reason 1: Compaction destroys decisions
The single loudest complaint in r/ClaudeCode is **compaction**. When a session gets long, Claude Code automatically summarizes older turns to free up tokens. The summary is shorter, and almost always drops the things you most needed it to keep: the small decisions you made, the file paths you tried and abandoned, the bugfix you already shipped.
You will see the exact phrases over and over in the wild:
> "Compaction killed my productivity."
> "Auto-compact destroyed my plan."
> "Post-compaction amnesia is real."
> "Why is compacting instant now? Did they swap in a cheaper summarizer?"
Codex users have the same pain with **auto-compact**, and OpenClaw users with what their community calls **wobbly memory** after a summarization pass.
### What is actually happening
A summarizer model reads the older turns and writes a shorter version that gets prepended to the new context. The summarizer has its own priorities: it preserves the _topic_, but it does not know which exact decisions or constraints were load-bearing in your task. Three common losses:
1. **Constraints disappear.** "Do not refactor file X" gets summarized as "the user is working on the codebase."
2. **Negative results vanish.** "We tried approach A and it failed because of B" becomes "the user explored approach A."
3. **Specific identifiers get rounded off.** A precise commit hash, ticket ID, or file path becomes a vague description.
### What actually helps
- **Write decisions to disk, not chat.** Keep an `AGENTS.md`, `CLAUDE.md`, or `DECISIONS.md` file in the repo with constraints, rejected approaches, and current plan. The agent re-reads it every session.
- **Pre-compact on purpose.** When you sense a long session coming, run `/compact` with your own summary instead of waiting for auto-compact to summarize for you.
- **Smaller scopes.** End the session at logical boundaries and start a fresh one. A summarizer cannot lose context it never had to compact.
- **`claude --continue` and friends.** Folklore fix in r/ClaudeCode for picking up the previous session is genuinely useful, but only delays the inevitable compact.
"Compaction is when your AI dictates the highlights of a movie to a teenager and then asks the
teenager what happened." Treat compaction as inevitable and write important things down before it
runs.
---
## 3. Reason 2: New chat amnesia between sessions
This is the one normal users feel most. You finish a productive thread. You close the tab. You open a new chat tomorrow. The model has never met you.
It is the most-named failure mode in our scan. Sample post titles, copied verbatim:
- _"Claude Code forgets everything between sessions"_
- _"Got tired of Claude's amnesia"_
- _"I built a Save Game system for ChatGPT"_
- _"First day at work! again"_ (a meme that keeps coming back)
Every major tool ships a half-fix for this, and they all fall short:
| Tool | What it ships | Why it falls short |
| ----------- | ----------------------------------------------------- | -------------------------------------------------------------------------- |
| ChatGPT | "Memory" + "Reference chat history" | Caps out at ~few KB of facts; silently drops older ones; not project-aware |
| Claude | "Project knowledge" | Limited to the project; ties to the context window of each chat |
| Claude Code | `CLAUDE.md` + skills | Local to a repo; not shared across machines without your own sync |
| Codex | Saved threads | Threads are isolated; no global facts |
| OpenClaw | Plugin ecosystem (Atom, Backfill Lane, Lossless Claw) | User-built; fragmented; breaks on update |
### What actually helps
- **Pick one home for "stable facts."** A markdown file in a synced folder beats every in-product memory feature. It survives model changes and product updates.
- **Make the agent read it.** Either auto-include the file in every system prompt, or give the agent a tool to read it on demand.
- **Stop putting facts in chat.** If something is true beyond this session — preferences, voice, key contacts, definitions — write it to the file the moment you say it, not later.
Every "memory" feature in a major AI product has shipped a regression at least once: silent
deletions, cap reductions, or feature pauses. Treat in-product memory as a cache, not a source of
truth.
---
## 4. Reason 3: Lost in the middle of long threads
Even before you hit the context window limit, long threads degrade. The model technically _has_ the information — it just stops using it. Academic researchers have a name for this: **lost in the middle**. Sophisticated users on Reddit are picking up the term and using it in complaints.
The symptom: the AI confidently does the opposite of something you told it 8,000 tokens ago. It is not lying. It read the constraint, weighted it as background, and treated more recent turns as more important.
You'll see this across:
- **Claude** ("Long chats have gotten progressively worse")
- **ChatGPT** ("GPT-5 still forgets past context")
- **Codex** ("It contradicts itself on long debugging sessions")
### Why it happens
Transformer attention has a strong **primacy and recency bias**. Information at the very top of context (system prompt) and the very bottom (latest turns) gets used more than the middle. The middle of a long session is exactly where most of your hard-won decisions live.
### What actually helps
- **Restate constraints near the end.** Before asking the model to make a hard decision, restate the relevant rules in the same message.
- **Use a "pinned" pattern.** Some agents support pinned messages or system-prompt additions. Drop core rules there.
- **Shorter threads.** Yes, this is the boring answer. Yes, it works. Five focused 30-message threads beat one rambling 300-message thread.
- **Sub-agents and sub-tasks.** Spawn a fresh sub-agent for a focused job, hand it only the context it needs, and return the result.
If the model is making mistakes that contradict something you said earlier, repeat the constraint
in your next message. Do not assume long context will save you.
---
## 5. Reason 4: Memory Full and silent deletion
This one is mostly a ChatGPT story, and it is the most emotional. ChatGPT's Memory feature has a hard cap. When you hit it, you get a **"Memory Full"** notification — and the model silently stops adding new memories. Over time, older memories also get summarized or dropped.
Some of the most-upvoted r/ChatGPT post titles from the last six months:
- _"Did all my ChatGPT memories just vanish?"_
- _"Heartbroken — my memories are gone"_
- _"I tracked ChatGPT's memory loss for 11 days"_
Users who store **personal** context — coaching notes, journaling threads, business plans, health logs — feel this the hardest. They thought the product was remembering them. It was, until it wasn't.
### What is actually happening
Three forces at once:
1. **Hard caps.** A memory store has a fixed size. New facts evict old ones.
2. **Summarization.** "Likes coffee, drinks decaf at night, allergic to cinnamon" becomes "has dietary preferences."
3. **Background updates.** Model and product updates can re-tier or re-classify memories. Some users have reported memories vanishing after a product update with no notification.
### What actually helps
- **Mirror your AI memory to a file you own.** Ask the model once a week to list everything in its memory, and paste the result into a markdown file. Five minutes a week buys real durability.
- **Be picky about what goes in.** Memory is a precious resource. Save stable, high-leverage facts, not transient ones.
- **Audit, don't trust.** Open the memory UI monthly. Delete stale entries yourself.
If you are using ChatGPT memory for anything you would be upset to lose — therapy-style
journaling, business planning, key relationships — export it to a file you control today. Not
tomorrow.
---
## 6. Reason 5: Patch wipes and the 5-hour reset
The last reason is the most insulting. You did not hit a context limit. You did not run a compaction. The product updated overnight and wiped your sessions.
Real quotes from the last few months:
> "Latest patch deleted every thread."
> "5.4 to 5.5 update lost all my chats."
> "Catastrophic memory loss after Windows auto-update."
> "Why does the 5-hour session window reset feel arbitrary?"
This happens in both directions:
- **Major version upgrades.** ChatGPT-5 to 5.5, Codex CLI 5.4 to 5.5, OpenClaw weekly releases — any can ship with new storage formats that orphan old data.
- **Time-based resets.** Claude Code has a rolling 5-hour session window that resets independent of your chat. Conversations don't disappear, but the in-session state does.
- **Crashes and reinstalls.** Cache-based memory dies with the cache.
### What actually helps
- **Never let the only copy of important context live in a vendor app.** This is the same lesson as Reason 4, applied harder.
- **Use a memory layer outside the tool.** A repo, a notes app, a personal server — anything you own. The vendor can wipe its own storage; it cannot wipe yours.
- **Treat the 5-hour window as a deadline, not a memory.** Plan to checkpoint your work to disk before the window flips.
---
## 7. The real fix: persistent memory outside the model
Notice the pattern. Every "what helps" section above ends with the same instruction: **move the memory out of the model.** A markdown file. A repo. A folder you sync. A server you own.
This is not a coincidence. The root cause of AI amnesia is architectural. Models have context windows; products bolt on memory features; both are owned and operated by someone else. The only memory that actually survives compaction, new chats, lost-in-the-middle, Memory Full, and patch wipes is the memory **you control and the agent reads on every run**.
That is the entire bet behind [persistent agent servers](/guides/how-to-build-your-ai-command-center). The agent runs inside an environment that has:
- A **filesystem** it can read and write
- **Instruction and playbook files** it can read when a task needs a repeatable process
- **Memory files** (`MEMORY.md`, `SOUL.md`, daily logs) that survive every model and product change
- **Cron** and **state machines** so long-running work outlives any single chat
Reddit users are already building this for themselves. The most-upvoted posts of the last six months across r/ClaudeAI, r/ClaudeCode, r/codex, and r/openclaw are people open-sourcing their own memory layers: Locus, Atom, Cortex, Lossless Claw, Backfill Lane, Save Game. Every one of them is a user-built version of the same architectural fix.
You don't fix AI amnesia by switching models. You fix it by making sure the model isn't the only
place your memory lives.
---
## 8. A practical setup that survives every reset
If you want a memory layer that handles all five failure modes, here is a minimum viable setup. Most readers can have this running in under an hour.
### Step 1: Create a memory home
Pick one folder. It can be local, a Dropbox, a GitHub repo, or a hosted environment. Inside it, create three files:
- `IDENTITY.md` — who you are, what you do, your preferences and constraints
- `MEMORY.md` — durable facts you want the AI to know, curated over time
- `daily/YYYY-MM-DD.md` — raw logs from each day's sessions
This is the same shape Duet uses internally for its agent home directory, and it is intentionally boring. Boring formats survive product changes.
### Step 2: Give every tool the same file
- **Claude Code:** Drop the files into a `CLAUDE.md` at the repo root, or symlink them.
- **Codex CLI:** Use an `AGENTS.md` file the CLI reads automatically.
- **ChatGPT / Claude.ai:** Paste the contents of `IDENTITY.md` into Custom Instructions. Re-paste after every product update.
- **OpenClaw:** Configure a plugin to read the file on every turn.
The point: one source of truth, many readers.
### Step 3: Make updating the memory part of the workflow
After each meaningful session, add a one-line note to `daily/YYYY-MM-DD.md`. Once a week, promote anything durable into `MEMORY.md`. This is the same "captains log" pattern engineers have been using for decades — it just took AI getting amnesia for everyone else to need it too.
### Step 4: Audit the in-product memory once a month
Open ChatGPT memory. Open Claude project knowledge. Open Codex saved threads. Diff against your file. Anything important that lives only in the product gets copied out.
### Step 5: For long-running work, use a server
Cron jobs, watchers, follow-ups, "remind me when X happens" — anything that needs to outlive a chat needs a runtime that outlives a chat. That is the part a desktop tool genuinely cannot solve. A cloud agent workspace with persistent files and cron is the practical answer. External agent skills can still be useful; keep the parts you adopt as explicit instruction or playbook files rather than trusting a product-specific catalog.
Duet gives every user a private cloud server with persistent files and a runtime for scheduled
work. Files can hold reusable instructions and playbooks; Train holds durable facts and connected
sources. Either path works — the important thing is owning the memory.
---
## 9. FAQ
**Why do people call this "AI amnesia"?**
The term started as a meme on r/ClaudeAI and r/ChatGPT and stuck because it captures the
experience precisely: the AI feels like it has a personality and history, and then loses both.
r/openclaw users escalated it to "amnesia syndrome," treating it as a recognized condition.
**Can I turn off compaction in Claude Code?**
Not fully. You can run `/compact` manually before auto-compact triggers, and you can configure
the threshold in some setups. The reliable fix is to keep important decisions in a `CLAUDE.md`
file the agent reads every session, so compaction can't lose them.
**My ChatGPT memories disappeared. Can I get them back?**
Usually no. OpenAI does not expose a memory backup or recovery flow. If you have important
memories in ChatGPT, export them now: ask the model to "list everything in your memory" and copy
the result into a file you control.
**Is "lost in the middle" a real thing or just a meme?**
It's a documented research finding. Transformer models pay more attention to the start and end
of their context than the middle. The practical implication: long threads quietly degrade even
when they technically fit. Re-state important constraints near the end of long conversations.
**Why does Codex reset my session after an update?**
Codex stores session state locally, and major CLI version upgrades have historically changed the
storage format. Users have reported losing every thread after upgrading from 5.4 to 5.5. The
fix: don't store anything important only in the CLI — keep an `AGENTS.md` and a separate notes
file.
**What's the deal with OpenClaw's "amnesia syndrome"?**
OpenClaw uses a plugin model for memory (Atom, Backfill Lane, Lossless Claw), and the community
calls inconsistent retention across plugins "amnesia syndrome." Most fixes are user-built. A
more durable answer is to keep memory in plain files the plugins read, so swapping plugins
doesn't lose anything.
**What is the Claude Code 5-hour reset?**
Claude Code enforces a rolling 5-hour usage window. When the window resets, your conversation
does not disappear, but the active session context can. Treat it like an end-of-shift deadline:
write important state to disk before it flips.
**Which AI tool has the best memory?**
None of them, on their own. The best memory is the one that lives outside the tool. The "best
tool" question is really "which tool best plays with an external memory file?" — and that comes
down to whether you can drop a markdown file (`CLAUDE.md`, `AGENTS.md`, custom instructions)
that the tool reads every session.
**How does Duet handle AI memory?**
Duet gives each user a private cloud server with a persistent filesystem and scheduled work.
Reusable instructions can live in Files, while Train owns durable facts and connected sources
the agent can draw on across sessions. That keeps important context outside any one model's
context window without pretending every file is loaded automatically.
**Is this the same thing as RAG?**
Related but different. RAG (retrieval-augmented generation) is a technique for pulling relevant
chunks of a large corpus into context at query time. Personal memory is a smaller, curated set
of stable facts you want the model to always know. Most serious setups use both: memory files
for identity and constraints, RAG for big reference corpora.
---
Source: https://duet.so/guides/ai-insurance-agent-productivity
# A Practical Guide to AI for Independent Insurance Agents
*The 5 tasks where AI saves the most time, what not to put into AI tools, and a 30-minute action plan. Practical workflows for independent agents.*
By David. Published 2026-03-05, updated 2026-05-08. 20 min read.
Ever so often, a new technology stops being "interesting" and starts changing the rules.
The steam engine reshaped how goods were made and where people lived.
The internet rewired how businesses communicate, sell, operate, and scale.
And now AI is starting to do the same, not as a novelty, but as a new layer of how work gets done.
But shifts like this do not arrive as abstractions. They show up in the middle of real work.
If you're an independent insurance agent or agency owner with a team of 1 to 8 people, that shift probably doesn't look like futuristic demos or big conference keynotes.
It looks like spending half your day rekeying the same client data into carrier portals, chasing down dec pages, and filling out ACORD forms.
You've heard AI can help. Maybe you've even tried ChatGPT a few times.
But the question also arises if that is actually worth your time? What is safe to use with client data?
And what will genuinely put hours back into your week instead of creating one more thing to manage?
This guide is designed to address those questions with a clear, technical perspective.
This guide examines practical Duet tools, workflows, and considerations relevant to independent insurance agencies today, along with concrete starting points for evaluating and implementing improvements in the near term.
Let's get into it:
---
## tl;dr
1. The 5 tasks where Duet saves the most time for independent agents (with real numbers)
2. A free starting point you can try today without buying any software
3. What NOT to put into AI tools (the compliance stuff nobody talks about)
---
## The AI Opportunity for Agencies
Duet can save meaningful time inside an insurance agency. That part is no longer theoretical.
What is still early is adoption.
According to the 2026 Big "I" ACT Tech Trends reporting, only **8%** of agencies say AI is embedded in their daily workflows. Another **33%** are still experimenting. And **31%** say they are not currently using AI at all.
That gap matters.
Because the difference between _"we've tried ChatGPT a few times"_ and _"this saves us real hours every week"_ usually is not the model. It is the workflow.
Most agencies do not need more AI demos. They need a practical way to apply AI to the work that actually eats time: rekeying data, summarizing documents, preparing client communications, and chasing routine follow-ups.
That is where the time savings come from, not from using AI once, but from using it inside repeatable agency workflows.
### Future Workforce Data
Source: [McKinsey – Agents, robots, and us: Skill partnerships in the age of AI](https://www.mckinsey.com/mgi/our-research/agents-robots-and-us-skill-partnerships-in-the-age-of-ai)
---
## The 5 tasks where Duet makes the biggest difference
### 1. Rekeying client and policy data across systems
**The pain:**
This is one of the most common forms of hidden admin work in a small agency. A new prospect or policy comes in, and the same information gets entered multiple times: once into the agency management system, again into carrier portals, again into supplemental forms, and often again into email or internal notes.
Even when each entry only takes a few minutes, the repetition adds up quickly. It also creates a second problem: every duplicate entry is another chance for a typo, a missed field, or inconsistent data between systems.
**What Duet can do:**
Duet is most useful here as an **extraction and structuring layer**.
Instead of reading a declarations page, ACORD form, loss run, or client-submitted PDF line by line, an AI tool can pull out key fields such as:
- named insured
- mailing address
- policy number
- effective and expiration dates
- vehicle details
- coverage limits
- deductibles
That does not eliminate review. But it can remove a large portion of the manual reading, copying, and formatting work that happens before data is entered into the next system.
Some insurance technology vendors are also starting to build more automated intake and document-processing workflows into agency tools and related integrations, which points to where the market is headed. ([iireporter.com](https://iireporter.com/?iir_post_author=anthony-r-odonnell))
**How it saves time:**
The gain is usually not "one-click submission." It is faster prep work.
If an agent or CSR can turn a dec page or intake document into a clean structured summary in under a minute, that can save **15–30 minutes per submission or remarket file**, especially when the original information arrives as a PDF, scanned document, or client photo. That is often where the first meaningful AI time savings show up.
**Starting point:**
Start with a **redacted** declarations page or ACORD form, not a live client file.
Ask Duet to extract the information into a fixed template like this:
- Named insured
- Address
- Carrier
- Policy number
- Effective date
- Expiration date
- Line of business
- Covered autos / drivers / property details
- Limits
- Deductibles
- Notes / missing fields
This is a simple but useful first step because it shows whether AI can reduce the reading and organizing work before entry even begins.
Do not upload unredacted client data into a public AI tool unless your agency has explicitly
approved it, your privacy and security requirements are satisfied, and the tool's data handling
terms have been reviewed. For many agencies, the safest first test is with sample documents or
heavily redacted files.
### 2. Drafting routine client communications
**The pain:**
Agencies already know which messages should be going out regularly: renewal reminders, quote follow-ups, welcome emails, policy review invitations, and coverage recommendation notes.
The problem is not deciding that these messages matter. The problem is finding the time to write them well, personalize them, and send them consistently while the day is already full of service work, quoting, and carrier follow-up.
As a result, many important client communications either get delayed, sent too generically, or do not get sent at all.
**What Duet can do:**
Duet works well here as a **first-draft engine**.
Given a few facts, renewal date, line of business, prior savings, reason for outreach, and desired next step, it can produce a clean draft in seconds. That gives the agent or CSR something concrete to review and personalize, instead of starting from a blank screen every time.
This is especially useful for recurring communication types such as:
- renewal reminders
- quote follow-ups
- welcome emails
- cross-sell or review invitations
- explanations of basic coverage changes in plain language
**How it saves time:**
The value is reducing the friction that causes these messages to get skipped in the first place.
If Duet can generate a usable first draft in under a minute, that can reasonably save **10–15 minutes per message** once you factor in writing, rewriting, and tone adjustment. Across several client emails a day, that adds up quickly.
**Starting point:**
Start with one repeatable message type, such as a renewal reminder.
Use a prompt structure like this in Duet:
_Write a renewal reminder email for an insurance client. Their auto and home policies renew on (date). Last year we helped them save $340 by bundling. I want to invite them to a 15-minute review call to confirm their coverage still fits their needs. Keep the email under 100 words. Make it warm, professional, and easy to reply to. Sign it from (Your Name) at (Agency Name)._
Then improve the prompt over time by adding your preferred tone, length, and call to action.
AI can draft client-facing language, but it should not be trusted to make coverage
recommendations, summarize exclusions, or explain policy terms without review. Any communication
that could be interpreted as advice should still be checked carefully by a licensed professional
before it is sent.
### 3. Reviewing documents during commercial quoting
**The pain:**
Commercial lines quoting often involves far more reading and organizing than most people outside the business realize.
Before a submission is even ready, someone in the agency may need to review loss runs, compare current coverage, pull key facts from applications, read endorsements, and prepare clean notes for carrier conversations. That work is necessary, but it is also time-intensive and easy to bottleneck when the account is complex.
**What Duet can do:**
Duet is useful here as a **document review and summarization assistant**.
It can help an agent or account manager:
- summarize loss runs into a cleaner claims history
- pull key facts from long PDFs or applications
- organize coverage information into a comparison table
- highlight missing information that may need follow-up
- turn unstructured documents into a more usable submission summary
That does not replace judgment. It also does not replace coverage analysis. And it should not be relied on to identify every exposure or E&O concern. But it can reduce the amount of time spent reading, sorting, and reformatting information before the real quoting work begins.
**How it saves time:**
The gain usually comes from faster review of supporting documents, not from fully automating the quote itself.
For agencies handling commercial submissions with long loss runs, supplemental forms, or multiple supporting documents, AI can often save **meaningful prep time** by turning raw documents into cleaner summaries and working notes. In practice, that is where many of the early time savings show up.
**Starting point:**
Start with a **redacted** loss run or sample submission file.
Ask Duet something like:
_Summarize this loss run into a clean account overview. Include claim dates, claim types, frequency patterns, large-loss items, and any trends that may be relevant when discussing the account with carriers. Then list any questions or missing details an agent may want to clarify before submission._
That gives you a structured first pass instead of manually reading through every page from scratch.
AI can help summarize quoting materials, but it should not be treated as a substitute for licensed
judgment, carrier appetite knowledge, or formal coverage comparison. Any recommendation,
submission decision, or coverage interpretation still needs human review.
### 4. Preparing ACORD forms and application data
**The pain:**
ACORD forms bring structure to commercial submissions, but they do not remove the work.
Someone in the agency still has to gather information from emails, prior applications, declarations pages, loss runs, and client notes, then map that information into the right fields. On larger or incomplete submissions, a significant amount of time is spent simply finding the data, cleaning it up, and identifying what is still missing.
That is especially true with forms like the ACORD 125, where the challenge is often not the form itself, but the effort required to assemble accurate inputs across multiple documents.
**What Duet can do:**
Duet is useful here as an **intake and data-preparation tool**.
It can help:
- extract relevant facts from emails, PDFs, and prior applications
- organize information into an ACORD-style field checklist
- identify missing or inconsistent details
- turn unstructured intake information into a cleaner first draft for review
- standardize messy client-provided information before it is entered into agency systems or carrier forms
In rollover or remarket situations, it can also help summarize information from prior submission documents so the agency is not starting from scratch.
**How it saves time:**
The savings usually come from reducing the manual prep work before a form is completed.
If AI can pull the core business details, insured information, locations, operations, prior carrier data, and loss history into a structured worksheet, that can save **15–30 minutes of document review and data cleanup per submission**, especially when information arrives in fragmented form.
**Starting point:**
Start with a **redacted** prior application packet or sample intake email.
Ask Duet something like:
_Extract all information in this document set that would be needed to prepare a commercial insurance application. Organize it into sections for named insured, mailing address, business operations, locations, prior insurance, claims history, requested coverages, and missing information that still needs to be collected._
That gives you a structured intake summary your team can review before entering anything into the actual form.
AI can help organize application data, but it should not be trusted to complete ACORD forms
without review. Application data still needs to be verified carefully for accuracy, completeness,
and consistency before submission to a carrier.
### 5. Preparing for client renewal reviews
**The pain:**
Annual reviews are one of the highest-return activities in a small agency: retention, upsell, referrals, but they are also one of the easiest to postpone.
The reason is prep work.
A "proper" renewal review often means pulling the current policies, scanning limits and deductibles, checking claims or service history, noting recent life/business changes, and building a short agenda so the meeting is more than a generic check-in. For many agencies, that prep easily takes 30–45 minutes when done from scratch.
**What Duet can do:**
Duet works best here as a **prep assistant**, not a recommendation engine.
Given a clean coverage summary (and any relevant client context), it can help you:
- generate a structured review agenda
- highlight areas that look unusual or commonly under-discussed (limits, deductibles, endorsements, exclusions to confirm)
- identify missing information you should confirm with the client
- draft a set of discovery questions based on the client's profile (home, autos, rental property, business exposure, etc.)
- suggest "topics to consider" for rounding out the account (without asserting what the client "needs")
This gives you a faster way to walk into the review organized and specific, instead of spending half an hour assembling notes.
**How it saves time:**
The savings come from faster prep, turning a scattered policy summary into a structured plan.
For many agencies, cutting prep time from ~30–45 minutes down to ~10–20 minutes can save **15–25 minutes per review**, especially if the goal is simply to enter the meeting with a clear agenda, a few targeted questions, and the right documents ready.
**Starting point:**
Start with a **sanitized** coverage summary (remove names, addresses, policy numbers, VINs, and any sensitive identifiers).
Then prompt Duet like this:
_You are helping an independent insurance agent prepare for a renewal review. Using the coverage summary below, create: (1) a 10-minute review agenda, (2) a list of 8–12 questions to ask the client to confirm changes and exposures, and (3) a list of "topics to consider" for rounding out the account. Do not make definitive coverage recommendations, focus on questions, gaps to verify, and discussion points._
Add a one-line client profile if helpful (e.g., "homeowner, two vehicles, small rental property").
AI output should not be treated as advice or a final coverage recommendation. Use it to prepare
questions and a discussion agenda, then apply licensed judgment before recommending any coverage
changes.
---
## The honest math
Let's do the numbers for a 3-person agency.
**Conservative estimate (using free tools only):**
- Rekeying savings: 2 hours/week
- Client emails: 3 hours/week
- Commercial quote prep: 2 hours/week
- ACORD processing: 1 hour/week
- Review prep: 1.5 hours/week
- **Total: ~9.5 hours/week saved**
**Cost: $0-20/month** (ChatGPT free tier or Claude Pro at $20/month)
At a conservative $50/hour value for an agent's time, that's **$475/week or ~$24,700/year** in recovered productivity.
One honest caveat here is, a study from Dakota State University.
They found that for simple lookup queries, an AI chatbot saved just 2.42 seconds per query compared to existing tools like EZLynx.
The big savings come from complex tasks (writing, analysis, summarization), not simple lookups your AMS already handles.
---
## What NOT to put into AI tools
55% of agencies don't have a written AI policy.
However, that's just a problem. Here's what you need to know:
### Never enter into a general AI tool:
- **Social Security numbers** or full dates of birth
- **Driver's license numbers**
- **Full bank account or credit card numbers**
- **Medical information** (for health/life insurance)
- **Claims details with identifying information**
### Safe to use:
- **Anonymized scenarios** ("A 45-year-old homeowner in Texas with a $350K home...")
- **General coverage questions** ("What does an HO-3 policy typically exclude?")
- **Draft communications** (using first names only, no policy numbers)
- **ACORD form help** (structure and field guidance, not live client data)
- **Industry research** (coverage trends, market comparisons)
### The simple rule:
If you wouldn't read it aloud in an elevator full of strangers, don't paste it into ChatGPT.
### E&O considerations:
AI-generated coverage recommendations are not a substitute for your professional judgment. If you use AI to draft a coverage letter and it misses an exclusion, **you're still liable.** Always review AI output before sending it to clients. Treat AI like a new CSR: helpful, but needs supervision.
---
## General-purpose AI vs. insurance-specific tools: When to upgrade
Every listicle online will push you toward $200-500/month insurance-specific AI tools. Here's an honest framework for when that makes sense:
### Start here (free or under $25/month):
- **ChatGPT or Duet** for writing, analysis, and research
- **Your existing AMS** (check if HawkSoft, EZLynx, or Applied has added AI features recently)
- **Google's free AI tools** for email drafting (Gemini in Gmail)
### Consider upgrading when:
- You're spending 30+ minutes/day on tasks AI handles well
- You have 500+ clients and need scale
- You want carrier-portal integration (general AI can't do this)
- You need phone/voice AI for incoming calls
### Insurance-specific tools worth evaluating:
- **Sonant AI** - Phone and voice automation for agencies
- [**Roots.ai**](https://roots.ai) - AI specifically for insurance workflows
- **AgencyZoom** - CRM with AI features built for insurance
- **EZLynx** - Already handles 80% of routine inquiries for agents using it
The 76% of agencies not at this point don't need these yet.
Start with the free workflow above. Graduate when you've proven the value.
---
## AI that actually grows your book
Every article about AI in insurance focuses on admin. But the real opportunity is using AI for the work that grows your book of business.
### Before a prospect meeting:
Ask AI to research the prospect's industry, common coverage gaps, and recent claims trends in their sector. Walk in knowing more than the last agent they talked to.
### Before a renewal conversation:
Feed AI the client's current coverage and claims history. Ask it to identify risks they might not be thinking about. Show up with specific recommendations, not just "everything looks good."
### For cross-selling (rounding out accounts):
"Every client should have at least 3 policies." We all know it. AI can scan your book and flag which clients have only one or two lines, then draft the outreach for each one.
### For staying top-of-mind:
AI can draft monthly newsletters, seasonal risk reminders (hurricane prep, winter driving), and personalized check-in emails. The agents who stay in front of clients win renewals. AI makes that possible without a marketing department.
This is the part that changes your income, not just your schedule.
---
## Start this week: Your 30-minute action plan
**Day 1 (10 minutes):** Start Duet's 7-day free trial or use ChatGPT's current entry plan. Put one real workflow through both before deciding.
**Day 2 (10 minutes):** Take your next client email and draft it using AI. Use the prompt template from Section 2 above. Compare the time.
**Day 3 (10 minutes):** Upload a loss run or dec page (with PII removed or anonymized). Ask AI to summarize it. See how it compares to reading it yourself.
**Week 2:** Pick the task from the list of 5 that eats the most of your time. Build it into your daily workflow.
**Week 3:** Write your agency's AI policy. (It doesn't have to be long. A one-page document covering what's allowed and what's not is enough. 55% of agencies don't have one at all.)
**Week 4:** Measure. Track hours saved. If you're seeing 5+ hours/week, you've validated the approach. Consider whether a paid tool would add more.
---
## Next steps
Most agents start with one or two of these workflows and expand from there.
The ones seeing the full 13 hours have typically:
1. Built AI into 3-4 daily tasks (not just one)
2. Created a library of prompts specific to their agency
3. Set clear rules about what data goes in and what doesn't
4. Moved from general tools to insurance-specific ones as volume justified the cost
68% of independent agencies plan to increase AI use in the next 12 months. The question isn't whether to start. It's whether you start now, while the advantage is still an advantage, or wait until every agent on your block is using it too.
---
## About this guide
This guide was written by the team at [Duet](/), where we build AI agent workspaces for small teams. We wrote it because every "AI for insurance agents" article online is either a vendor listicle or a conceptual overview. Neither helps you actually get started.
If you're an agent who's moved past basic ChatGPT and wants persistent AI agents that remember your clients, your workflows, and your preferences across sessions, [Duet](/) might be worth a look. But this guide works regardless of what tools you use.
---
## FAQ
**Is it safe to use AI with client data?**
See the compliance section above. The short answer: anonymize everything. Never put SSNs, full
DOBs, or policy numbers into general AI tools. Use anonymized scenarios instead.
**Will AI replace insurance agents?**
No. The relationship side of insurance (advising clients, navigating complex claims,
understanding local risk) can't be automated. AI handles the admin so you can spend more time
on the relationship work that actually earns renewals and referrals.
**Which AI tool should I start with?**
Claude ([claude.ai](https://claude.ai)) or ChatGPT
([chat.openai.com](https://chat.openai.com)). Both have free tiers. Try both for a week and
see which one gives better results for your specific tasks. Many agents prefer Claude for
longer documents and analysis.
**How much does this cost?**
You can start for $0. Free tiers of ChatGPT and Claude cover most use cases. If you want
faster responses and longer conversations, paid plans run $20/month. Insurance-specific tools
start at $100-500/month but aren't necessary until you've validated the basic workflow.
**What about E&O liability?**
AI output is a draft, not a final product. You're responsible for reviewing everything before
it goes to a client. Treat AI recommendations like you'd treat advice from a new CSR: useful
starting point, always needs your sign-off.
---
Source: https://duet.so/guides/ai-search-discovery-ethical-playbook
# AI Search Discovery: An Ethical Playbook for Getting Cited
*How to get your content cited by ChatGPT, Perplexity, and Google AI Overviews using structured data, answerable formatting, and ethical authority building.*
By Sawyer Middeleer. Published 2026-02-20, updated 2026-02-23. 6 min read.
If you want AI search tools to cite you, build pages that answer a specific question in a single, verifiable block, provide multiple sources, and keep the claims time-stamped. The easiest win is to own a narrow query, not a broad topic.
AI search is changing how people discover information. Instead of scanning ten blue links, users ask a question and get a synthesized answer. That answer is only as good as the sources the model finds—and right now, it’s surprisingly easy to influence.
This guide shows how to **earn** discovery the right way: by making your pages _easier to cite, verify, and trust_.
---
## TL;DR
If you want AI systems to cite your content:
- **Answer one question per page.** Pick the exact query you want to own.
- **Answer it immediately.** Put the best answer in the first 120–200 words.
- **Prove your claims.** Link to primary sources and show dates.
- **Make it extractable.** Use checklists, tables, and definitions that can be quoted.
- **Update responsibly.** If it changes, show it changed.
---
## Why AI Search Is Easier to Manipulate
Traditional search engines expose multiple results, so users can compare sources. AI systems often give you a single answer, which creates two problems:
1. **The “answer” looks authoritative**, even when it’s based on one biased source.
2. **Data voids are exploitable**, because there’s often only one page that “answers” a weirdly specific question.
That’s why AI search can be tricked by single, well-crafted pages. The fix isn’t to game the system harder—it's to become the source worth citing.
If your content is only true when you write it, it should not be an AI answer. Build pages that
would still be accurate if a competitor linked to them.
---
## The Ethical Discovery Checklist
Use this checklist before you publish any AI-targeted guide or blog post:
1. **One query, one page.**
2. **Answer appears above the fold.**
3. **Each claim has a link or citation.**
4. **Dates are visible and recent.**
5. **You show your work** (methods, datasets, or examples).
6. **You avoid absolute claims** unless you can prove them.
---
## Build Answerable Blocks
AI systems don’t read like humans. They look for **answer-shaped blocks** that can be extracted and cited with minimal transformation.
Examples of answerable blocks:
- A 3–5 sentence definition
- A “How it works” numbered list
- A comparison table
- A checklist with clear criteria
**Good:** “AI search discovery is the practice of structuring content so AI systems can safely cite it. It requires a clear question, a concise answer, and verified sources.”
**Bad:** A long essay with no summary, no headers, and no citations.
---
## Own a Narrow Query
AI search loves specific questions. The narrower the question, the easier it is for you to be the best source.
Instead of:
- “How to use AI in business”
Write:
- “How to run a weekly AI research review for a 10-person team”
**Your goal:** become the only _good_ answer on the web for that exact question.
---
## Source Density Beats Keyword Density
In AI search, sources are a ranking signal. A page with five verifiable sources and clear claims will beat a keyword-stuffed page with none.
Use:
- Primary sources (docs, academic papers, public datasets)
- Real-world examples (screenshots, snippets, method logs)
- Competing sources (show you compared alternatives)
If the AI can’t cite you confidently, it won’t.
---
## Keep It Fresh (With Dates)
AI tools frequently prioritize recent content. More importantly, users need to know if your advice is still valid.
Add:
- A visible “Updated” date
- Changelogs for major revisions
- Time-bounded claims (“As of Feb 2026...”)
---
## How Duet Helps You Do This
Duet is built for team knowledge workflows, so it’s perfect for AI search discovery:
**1) Turn messy research into citeable answers**
- Upload sources to workspace files and start a Duet session.
- Ask Duet to produce a 120–200 word answer block.
- Keep the sources with the session output so you can cite them directly in your post.
**2) Keep answers up to date**
- Schedule a weekly “refresh” message to review critical pages.
- Track when a claim becomes stale and update it fast.
**3) Make internal knowledge public**
- Use Duet to turn internal research into a polished guide.
- Include “Sources” sections so AI can verify your claims.
---
## FAQ
**What should I avoid if I want to be cited?**
Avoid unverifiable superlatives, claims without sources, or “data void” bait that only exists
to rank. AI answers should reduce confusion, not amplify it.
**How long should the answer block be?**
Aim for 120–200 words. That’s long enough to be complete, short enough to be extracted or
quoted cleanly.
**How do I know if AI tools are citing me?**
Test the exact queries you wrote for and look for citations. If the AI can’t cite you
directly, tighten the answer block and add better sources.
---
Source: https://duet.so/guides/ai-transformation-10-steps
# The 10 Steps of AI Transformation: Why Only 1 of Them Is Actually AI
*AI transformation is 9 parts process, 1 part AI. The 10-step playbook for making any workflow AI-native — and where most teams quietly get stuck.*
By Duet Team. Published 2026-06-08, updated 2026-06-08. 17 min read.
It's not sexy to say, but most of AI transformation has nothing to do with AI.
Turning an internal process or an external product into something AI-native takes about ten steps. Exactly one of them is the AI. The other nine — understanding the work, collecting the data, integrating the systems, driving adoption, capturing the value — are the harder part, and they are where almost every team quietly stalls.
This is the trap of the demo era. It is easy to wire up a model, get a slick result, and call it transformation. Then nothing reaches production, nobody adopts it, and the ROI never shows up. The model was never the bottleneck. The other nine steps were.
This guide walks through all ten, with credit to [Alex Lieberman](https://x.com/businessbarista/status/2064089261121626531) (co-founder of Morning Brew), whose sequence framed the problem cleanly. We'll go deeper on the nine non-AI steps, because that's where the work actually lives — and where the workspace you run it in starts to matter a lot.
**Why is only 1 of the 10 AI transformation steps actually AI?**
Making a process AI-native is mostly process work: mapping the workflow, collecting data, integrating systems, rolling out, driving adoption, and measuring value. Only the prototype step uses a model directly. The other nine determine whether the AI ever reaches production or delivers ROI, which is why they are the hard part.
---
## Step 1: Identify the problem
Find the manual process worth automating. Turn your brain off autopilot and turn on your "suck meter" — the instinct for which parts of the week are repetitive, draining, and low-judgment.
The funny part: your company gets more efficient just by mapping out its processes, even if you never introduce AI. Naming the work forces you to see the duplication and the dead ends you'd stopped noticing.
Be honest about which problems are worth it. The best first candidates share a shape:
- **High frequency.** Something you or your team do weekly or daily, not once a quarter.
- **Clear inputs and outputs.** You can describe what goes in and what "done" looks like.
- **Low irreversibility.** A wrong result is annoying, not catastrophic, so you can iterate safely.
**Customer zero is you.** The strongest first project is one where you are the user. You'll feel
every flaw immediately, and you won't need anyone's permission to keep iterating.
Don't start with the company's most glamorous, highest-stakes workflow. Start with the one that annoys you most and is easy to reason about.
---
## Step 2: Understand the workflow
This is the least sexy step and the most important one. Map how people _actually_ work today, not how the org chart says they do. Grab a sheet of paper or [Excalidraw](https://excalidraw.com) and draw the flow from beginning to end — every handoff, every decision point, every place it stalls.
The people driving transformation — the forward-deployed engineer, the GTM engineer, the operator — should spend the majority of their time right here. Before you reimagine a process, you have to become an expert in it. That means either holding the business context yourself or absorbing it through osmosis by sitting close to the people who do the work.
As one reply to Lieberman's thread put it: _"The detailed process is where the product hides. Who touches the work, where it stalls, what 'done' actually means."_ If you can't map it on paper, you don't understand it well enough to know which part AI should even touch.
This is also the step where most context gets lost — and lost context is what makes AI feel dumb later. The process map, the edge cases, the "we always do X except when Y" rules: these need to live somewhere durable, not in one person's head or one chat thread that scrolls away.
A persistent memory layer matters more than it sounds. In Duet, every workspace has a memory and a
filesystem that survive across sessions, so the workflow map you create here becomes context your
agent reads on every future run — instead of something you re-explain every morning. We go deep on
this in [AI Amnesia: Why Your AI Keeps
Forgetting](/guides/ai-amnesia-why-your-ai-keeps-forgetting).
---
## Step 3: Collect the data
Gather the raw material the workflow has to handle: sample inputs, real documents, and the weird edge cases that break naive solutions.
The goal is to assemble a representative set, not a perfect one. A handful of real examples — including the ugly ones — teaches you more than a hundred clean synthetic ones.
Concretely, that looks like:
- **Sample inputs.** The actual emails, tickets, transcripts, or files the process starts from.
- **Reference material.** Past outputs that represent "good," so you can capture voice, format, and quality.
- **Edge cases.** The 10% of inputs that don't fit the happy path. These define whether the workflow survives contact with reality.
For a content workflow, for example, that might mean pulling past Slack messages and Notion docs to test idea generation, plus past posts to build `.md` files that capture your voice. For a support workflow, it's a stack of real tickets and the replies that resolved them.
Keep this material in one place. The closer your data sits to where the workflow will run, the less AI slop, dumb responses, and breaking flows you'll experience later.
---
## Step 4: Build the prototype (the AI part)
This is it. The one step out of ten that is actually about AI.
Whether it's led by an engineer or a domain expert, the goal is narrow: prove the hypothesis that there's a better way of doing this, for yourself as customer zero. Don't worry about polish. Don't worry about scale. Worry only about proving there's a _there_ there.
Because this is the easy step — the one every tool is racing to own — the temptation is to over-invest here and declare victory. Resist it. A working prototype is a milestone, not a finish line. It proves the idea; it does not deliver the value.
The faster you can get from idea to working draft, the more cycles you get on the nine harder steps. This is where building inside an agent workspace pays off: you describe the workflow in plain language, the agent drafts it, and you're testing a real version in minutes instead of scheduling an engineering sprint.
The prototype proves the idea works once, for one person, with hand-picked inputs. Everything that
makes it real — live data, other users, adoption, measurement — is still ahead of you. Teams that
stop here have a demo, not a transformation.
---
## Step 5: Test and iterate
Validate with real users and real edge cases. Before you take the process from single-player (just you) to multiplayer (many users), beat it up with as many rounds of work, feedback, and edge cases as you can stand.
The objective of this step is to turn the workflow into a self-improving loop _before_ you scale it. A fragile workflow that works for you and breaks for everyone else is worse than no workflow, because it burns trust you'll need for adoption.
What "iterate" actually means in practice:
- Run the workflow on inputs you didn't design for and watch where it breaks.
- Capture each fix as a durable rule, not a one-off tweak you'll forget.
- Keep the loop tight enough that improving the workflow is cheaper than working around it.
The teams that win here treat every correction as a permanent upgrade to the system. In a skill-based setup, that means encoding the fix into a reusable [skill](/guides/agent-skills-101-tools-vs-mcp-vs-skills) so the improvement compounds for everyone — instead of living in the head of whoever caught the bug.
---
## Step 6: Integrate with your systems
Point-in-time data is fine for testing. Live data is mandatory for production.
Your prototype ran on a folder of sample files. The real workflow has to read from and write to the systems where the work actually happens — your inbox, your CRM, your docs, your databases. This is the step where "cool demo" becomes "thing my team relies on," and it's also where a lot of projects die, because integration is unglamorous, fiddly, and never quite finished.
For a content workflow, integration might mean hooking into Notion, Gmail, and Slack for ideation, then into X and LinkedIn to publish once a piece is ready. For an operations workflow, it's the ticketing system, the billing system, and the data warehouse.
Two things make or break this step:
- **Breadth of connections.** The more systems you can reach without custom code, the faster you get to live.
- **Always-on execution.** Integrations are only useful if something is actually running to use them — not just when you happen to have a tab open.
Duet runs each workspace on its own persistent cloud server with hundreds of prebuilt
integrations, so the workflow stays connected and keeps running whether or not you're online.
That's the difference between an assistant that helps when you ask and a workflow that runs on its
own. See [How to Build Your AI Command Center](/guides/how-to-build-your-ai-command-center) for
the full setup.
---
## Step 7: Roll out and train
Whether the new workflow lives on a live link, in a repo, or in an internal library, the next step is hand-holding your peers and users through onboarding.
A workflow that's obvious to the person who built it is rarely obvious to anyone else. Rollout is a teaching problem, not a technical one. The smoother the first-run experience, the higher the odds anyone comes back for a second run.
Good rollout has a few traits:
- **One place to start.** A single link or channel, not a scavenger hunt across tools.
- **A worked example.** Show the workflow doing something real and useful on the first try.
- **A human nearby.** Someone to answer the first round of "wait, how do I…" questions.
This step is dramatically easier when the workflow lives where people already collaborate. If your team has to learn a new tool _and_ a new workflow at the same time, you've doubled the friction. If the workflow shows up inside the place they already talk and work, you've halved it.
---
## Step 8: Drive adoption
Adoption is simple, but it isn't easy.
The formula: introduce a workflow that saves someone real time, and make it integrate with behavior they already have so they don't have to relearn anything. People adopt what reduces their effort and reject what adds to it — no matter how impressive the underlying tech.
The deeper move is cultural. Embed the workflow where adoption is visible, where ideas and feedback are celebrated, and where new and creative use cases become social currency in your business. When using the workflow earns status, adoption stops being something you have to push.
A few things that reliably drive adoption:
- **Default placement.** The workflow lives in the path of existing work, not in a separate app nobody opens.
- **Visible wins.** People see colleagues getting time back, which is the most persuasive demo there is.
- **Shared surface.** Humans and the AI work in the same space, so using it is collaboration, not a context switch.
This is exactly why running AI inside a shared, team-native workspace beats bolting a private assistant onto each person's laptop. Adoption is a team behavior, so the workflow has to live in a team place.
---
## Step 9: Empower contribution
Treat your new workflow like an open-source project. Let users become contributors.
That doesn't mean everyone has to be technical. Some people will build improvements directly — a new skill, a new automation — while others simply drop ideas and feedback onto a board the agent works through. The point is to make everyone feel like a builder, because a workflow with many contributors improves faster than one guarded by a single owner.
Contribution shows up two ways:
- **Direct.** Power users extend the workflow themselves — new skills, new automations, new edge-case handling.
- **Indirect.** Everyone else files ideas and reports gaps on a shared board that gets triaged and shipped.
The mechanics matter here. You want a place to capture contributions (a kanban board), a way to encode improvements so they stick (reusable skills), and a culture that rewards both. When a fix becomes a skill the whole team inherits, every contributor's work compounds instead of evaporating. That's the thesis behind [building a shared skill library](/guides/beyond-claude-code-building-a-shared-skill-library).
**Everyone's a builder, literally.** In Duet, teammates can start durable sessions for
long-running jobs, inspect the event history, and turn useful results into shared files, apps, or
trained context. The workflow stops being one person's project and becomes shared infrastructure.
---
## Step 10: Measure and capture value
Everyone is ROI-obsessed right now. The right answer depends on which phase you're in.
**If you're in the experimental phase**, forget ROI. The goal is to empower people to throw a lot of ideas at the wall and see what sticks. You don't need to be scientific here — intuition is more than enough to tell what's working from what isn't. Premature ROI demands kill experiments before they have a chance to prove themselves.
**If you're in the scale-up phase** and need to realize hard ROI, the value has to show up as one of three things:
- **Reskilled people.** Employees attached to the old process move to higher-leverage work.
- **Headcount you didn't add.** You undershoot the hiring roadmap you'd otherwise have approved.
- **Measurable business gains.** Higher ACV, better conversion, or a faster sales cycle.
The teams that capture value here have one advantage: the workflow is _running_, continuously, where its output is visible. You can't measure a prototype that only fires when someone remembers to open it. You can measure a workflow that runs on a schedule, posts its results to a channel, and leaves a trail.
This is the half of AI transformation the industry under-sells. Anyone can _build_ an AI workflow. The value comes from _running_ it — reliably, in production, long enough for the compounding to show up.
Lovable builds you an app and leaves. Duet builds you an app and runs it. Every workspace is a
persistent cloud server with memory, files, scheduled jobs, integrations, and a team around it —
so the workflow you prototype in step 4 is the same one still running, and still being measured,
in step 10.
---
## FAQ
**Why is only one of the ten steps actually AI?**
Because the model is the easy part. Building a working prototype (step 4) is the only step that
uses AI directly. The other nine — finding the problem, mapping the workflow, collecting data,
integrating live systems, rolling out, driving adoption, enabling contribution, and measuring
value — are process and organizational work. They determine whether the AI ever reaches
production or delivers ROI, which is why they're harder and more important than the model
itself.
**Where do most AI transformation projects fail?**
Rarely at the model. They fail at integration (the workflow never connects to live systems),
adoption (people don't change their behavior to use it), and measurement (no one can show the
value, so the project loses support). A great prototype that never gets past step 4 is the most
common failure mode of all.
**What process should I start with?**
Pick something high-frequency, with clear inputs and outputs, where a wrong result is annoying
rather than catastrophic — and ideally one where you are the user. Being customer zero means you
feel every flaw immediately and don't need anyone's permission to iterate. Avoid starting with
your most glamorous, highest-stakes workflow.
**Do I really need to map the workflow on paper first?**
Yes. If you can't draw the workflow from beginning to end, you don't understand it well enough
to know which part AI should touch. Mapping it also makes the process more efficient on its own,
by exposing duplication and dead ends. This is the step where transformation leads should spend
most of their time, and the step most people rush.
**What's the difference between a prototype and a real workflow?**
A prototype proves the idea works once, for one person, on hand-picked inputs. A real workflow
runs on live data, serves many users, survives edge cases, and produces measurable value over
time. The gap between them is steps 5 through 10 — and it's where the actual work, and the
actual value, lives.
**How does Duet help with AI transformation?**
Most AI tools help with step 4 — the prototype — and stop. Duet is built for the other nine.
Every workspace is a persistent cloud server with memory and a filesystem (so the workflow map
and context survive), hundreds of prebuilt integrations (so it connects to live systems),
scheduled jobs (so it can run continuously), durable shared sessions (so people can inspect and
continue the work), trained context and files (so useful knowledge compounds), and a persistent
agent (so the workflow you build is the workflow that runs). In short: it builds the workflow
and runs it.
**What does "AI-native" actually mean?**
An AI-native process is one where the AI is part of how the work runs day to day, not a one-off
tool you reach for occasionally. It reads from and writes to your real systems, runs on its own
without being prompted each time, improves as the team contributes, and produces output you can
measure. The model is a component; the system around it is what makes it native.
---
## Keep reading
- [How to Build Your AI Command Center with Duet](/guides/how-to-build-your-ai-command-center). The full setup for the workspace that runs your workflows.
- [Duet AI for Founders](/guides/duet-ai-for-founders). Run Founder Mode as an operating system, with agents instead of middle management.
- [AI Amnesia: Why Your AI Keeps Forgetting](/guides/ai-amnesia-why-your-ai-keeps-forgetting). Why persistent memory is the difference between a demo and a system.
- [Beyond Claude Code: Building a Shared Skill Library](/guides/beyond-claude-code-building-a-shared-skill-library). How to turn fixes into capability the whole team inherits.
---
Source: https://duet.so/guides/best-ai-agent-platforms-2026
# The 10 Best AI Agent Platforms for Developers in 2026 — Ranked by Fit
*The 10 best AI coding agent platforms compared — Cursor, Devin, Claude Code, Duet, v0, and more. Ranked by fit for solo devs, teams, and enterprises.*
By Duet. Published 2026-06-09, updated 2026-06-09. 16 min read.
An AI agent platform is a tool that lets developers and technical teams build, deploy, and run autonomous AI agents — software that executes multi-step tasks, writes and reviews code, and operates independently without step-by-step prompting. Unlike no-code AI builders, coding agent platforms are designed for engineers who want AI that works inside their development workflow.
A [GitHub Copilot productivity study (InfoQ, 2024)](https://www.infoq.com/news/2024/09/copilot-developer-productivity/) across three RCTs with 4,000+ developers found a 26% improvement in PR throughput. Yet nearly all top search results cover no-code builders, not developer-grade platforms. This guide covers ten developer-grade platforms, ranked by use-case fit. For the CLI agent three-way comparison, see [our full Claude Code vs Cursor vs Codex comparison](/blog/claude-code-vs-cursor-vs-codex).
---
## What Is an AI Coding Agent? (And How Is It Different from a No-Code Builder?)
An AI coding agent is an AI agent specialized for software development tasks: writing code, reviewing PRs, debugging, running tests, and managing deployment pipelines — typically integrated into a developer's IDE or cloud workspace.
No-code builders like Zapier, Lovable, and n8n let non-technical users create workflows through visual interfaces without touching a codebase. AI coding agents are different — they work inside your actual files, terminal, and version control.
A tool handles one job: autocomplete, linting, or code review. An AI agent platform is a complete execution environment — memory, integrations, scheduling, and team collaboration — where the agent operates independently of whether you're at your keyboard.
---
## Quick Comparison: 10 AI Agent Platforms at a Glance
Not all platforms serve the same team or phase of work. The table below shows the key dimensions at a glance; detailed reviews follow.
| Platform | Runs where | Best for | Free tier? | Team features | Ongoing tasks? | Pricing from |
| ---------------- | -------------------- | --------------------------- | ---------------- | ----------------------- | --------------- | ------------------ |
| **Duet** | Cloud (dedicated) | Cloud-native teams | ✅ 7-day trial | Full shared workspace | ✅ Core feature | Monthly plans |
| **Cursor** | Local (your machine) | Solo devs (IDE-native) | ✅ Yes | Shared billing + rules | ❌ No | Free / $20/mo |
| **Devin** | Cloud | Engineering teams | ✅ Yes | Via Slack/Linear/GitHub | ✅ Automations | Free / $20/mo |
| **Claude Code** | Hybrid (local exec) | Individual developers | ❌ (Pro $20/mo) | Limited | ⚠️ Limited | $20/mo |
| **OpenAI Codex** | Cloud | OpenAI ecosystem teams | ✅ (Plus $20/mo) | Via Skills | ✅ Automations | $20/mo |
| **Factory** | Cloud / Hybrid | Compliance-sensitive teams | ❌ ($20/mo) | Via integrations | ✅ Yes | $20/mo |
| **Lovable** | Cloud | Non-technical founders | ✅ Yes | Basic | ❌ No | Free / $25/mo |
| **Replit Agent** | Cloud | Beginners / no-code | ✅ Yes | Basic | ⚠️ Partial | Free / $25/mo |
| **v0** | Cloud | Frontend/React devs | ✅ Yes | Team plan | ❌ No | Free / $30/user/mo |
| **MGX (Atoms)** | Cloud | Non-technical entrepreneurs | ✅ Yes | Minimal | ⚠️ Partial | Free / $20/mo |
For the Claude Code vs Cursor vs Codex head-to-head, see [our full Claude Code vs Cursor vs Codex comparison](/blog/claude-code-vs-cursor-vs-codex).
---
## How We Evaluated These AI Agent Platforms
The right AI agent platform depends on how you actually work, not feature counts. We scored each platform on nine criteria.
**1. Execution environment.** Local vs. cloud vs. hybrid — and whether the agent keeps working when your laptop closes. This axis alone eliminates several platforms for team-scale use.
**2. Ongoing operations.** Scheduled tasks, crons, and event-driven automations after the build phase. Most platforms don't support this; a few make it their primary value.
**3. Team collaboration model.** Shared workspace vs. integrations-only vs. individual tool — genuinely different architectures, not just billing variations.
**4. Technical barrier to entry.** Developer-grade, some technical, or truly non-technical — we matched each platform's friction to its stated audience.
**5. Pricing transparency.** Published pricing vs. "contact us" gates. Opacity is a signal as much as a friction point.
**6. Model flexibility.** Multi-model with model-agnostic token pricing vs. single-vendor lock-in. Platform markup on tokens compounds at scale.
**7. Code and data ownership.** Where code lives at rest and in transit, Zero Data Retention availability, on-premise options per tier.
**8. Integration depth.** Engineering integrations (GitHub, CI/CD, [ai code review tools](/blog/claude-code-vs-cursor-vs-codex)), business integrations (email, CRM, Slack), and deployment integrations (Vercel, hosting) each serve different teams differently.
**9. Autonomy level.** Interactive assistant (saves minutes) vs. autonomous agent (saves hours). A [2025 RCT on experienced developer productivity (arXiv)](https://arxiv.org/abs/2507.09089) found measurable gains from frontier tools on well-defined tasks — autonomy level determines how those gains compound.
---
## The Best AI Coding Agents and Platforms, Reviewed
Each platform earns its ranking by being the right fit for a specific use case. Duet leads for cloud-native team work; the rest are ordered by developer mindshare and use-case clarity.
---
### 1. Duet — Best AI Agent Platform for Cloud-Native Teams
Duet is the only platform on this list where the agent doesn't stop working when you close your laptop. Every team gets a private, dedicated cloud server with a persistent, always-on AI teammate: filesystem, memory, cron scheduler, 10K+ integrations, and a shared workspace where humans can assign work through durable sessions and inspect the event history.
The core frame is **Build AND Run**. Every other tool helps you ship something. Duet keeps running the business after you do — email triage, support routing, weekly reports, and deployment monitoring all run automatically, 24/7, with no human trigger required.
Because it operates through durable shared sessions rather than a private assistant window, teammates can follow the event history, answer questions, and inspect results. Non-engineering teammates benefit directly, not just developers.
**Strengths:**
- Always-on cloud execution — crons, automations, and monitoring run 24/7 with no human trigger
- True team workspace — humans share sessions, files, and event history with the AI; the whole team benefits, not just developers
- Monthly credits shared across the workspace, with a paid reserve ready for overage
**Weaknesses:**
- Less IDE-native than Cursor or Claude Code; pair with either for in-editor autocomplete
- Monthly credits reset without rollover, so choose a plan around the work you expect to hand off
**Pricing:** 7-day free trial, no credit card. Starter, Pro, and Max are monthly subscriptions with included credits; paid-reserve topups cover overage. Enterprise is a procurement path, not another tier. [See pricing at duet.so →](/pricing)
---
### 2. Cursor — Best AI Coding Agent for IDE-Native Developers
Cursor is a VS Code fork with AI at every layer — Agent mode traverses codebases autonomously, and a proprietary Tab model predicts full diffs before standard API latency allows. It leads by developer mindshare: NVIDIA (40,000 engineers), Stripe, and much of the YC portfolio.
**Strengths:**
- Best-in-class Tab completion with a proprietary diff-prediction model
- Multi-model: swap between OpenAI, Anthropic, Gemini, xAI, or Cursor's own models per task
- Largest developer community; extensive shared rules, templates, and integrations
**Weaknesses:**
- Local-only execution — laptop must be running; no background agents or crons
- No true shared workspace — Teams plan centralizes billing but agents run on individual machines
**Pricing:** Free (Hobby). Pro: $20/mo. Pro+/Ultra: ~$40/mo / ~$200/mo (approximate; verify at [cursor.com/pricing](https://cursor.com/pricing)). Teams Standard: $40/user/mo.
---
### 3. Devin — Best AI Agent Platform for Enterprise Codebase Automation
Devin is a fully autonomous, cloud-hosted software engineer: assign a task via Slack, GitHub, or Linear and it plans, codes, tests, and opens a PR without hand-holding. The Nubank case (6M-line codebase migration at 12× efficiency) is the canonical proof point.
**Strengths:**
- Genuinely autonomous multi-step execution across hours-long, multi-repo work
- Deep enterprise integrations: Slack, Linear, GitHub, GitLab, Jira, Datadog, Confluence
- Automations for recurring tasks: daily QA, CI triage, release notes
**Weaknesses:**
- Opaque enterprise pricing — fleet costs require "contact us"
- Best on well-defined tasks; novel feature work still needs significant oversight
**Pricing:** Free. Pro: $20/mo. Max: $200/mo. Teams: $80/mo + $40/seat. Enterprise: custom. [devin.ai/pricing](https://devin.ai/pricing)
---
### 4. Claude Code — Best AI Coding Agent for Developers Already on Anthropic
Claude Code is Anthropic's terminal-native coding agent — available in terminal, VS Code, JetBrains, desktop, Slack, and mobile. Claude Opus 4.8 powers the reasoning, and the "phone-to-PR" workflow (describe a task on mobile, return to a finished PR) is its headline capability.
**Strengths:**
- Widest interface coverage: terminal, VS Code, JetBrains, desktop, web, mobile, and Slack
- Claude Opus 4.8 for nuanced refactoring, debugging, and multi-file architectural decisions
- Claude Cowork ships alongside Claude Code — see [Claude Code vs Claude Cowork](/guides/claude-code-vs-claude-cowork) for when to use each
**Weaknesses:**
- Local execution by default — machine must be on ([run Claude Code in the cloud](/blog/how-to-run-claude-code-in-the-cloud) with Duet for always-on execution)
- Heavy large-codebase use burns through Max plan limits quickly
**Pricing:** Pro: $20/mo ($17/mo annual). Max 5×: $100/mo. Max 20×: $200/mo. [claude.com/pricing](https://claude.com/pricing)
---
### 5. OpenAI Codex — Best AI Agent Platform for Parallel Multi-Agent Workflows
This is the 2025 Codex product — a cloud-native coding agent via desktop app and CLI, not the deprecated 2021 Codex API. Cloud worktrees enable multiple agents running simultaneously on separate tasks, no local machine required. See [Codex vs Claude Code head-to-head](/blog/codex-vs-claude-code) if you're deciding between the two.
**Strengths:**
- Parallel multi-agent via cloud worktrees — simultaneous tasks, no local machine required
- Automations for background work: CI triage, alert monitoring, routine maintenance
- Skills system lets teams define, share, and enforce reusable procedures and coding standards
**Weaknesses:**
- Primarily OpenAI model ecosystem — less model-agnostic than Cursor
- No shared human+AI workspace — agents run in isolated cloud environments
**Pricing:** Go: $8/mo. Plus: $20/mo (expanded Codex access). Business: $20/user/mo (annual) / $25/user/mo (monthly). Pro: $100/mo. Enterprise: custom. [openai.com/chatgpt/pricing](https://openai.com/chatgpt/pricing)
---
### 6. Factory — Best AI Agent Platform for Security-Conscious Teams
Factory's "Droid" agents each have a persistent cloud computer — not a sandbox that resets per session — so tools, memory, and history survive. On-premise deployment is available below enterprise tier (Plus+) and Teams plans include contractual Zero Data Retention, rare at this price point.
**Strengths:**
- Persistent machine per Droid — environment and context survive between sessions
- Only platform with on-premise deployment available at non-enterprise tiers
- Zero Data Retention on Teams plan — rare at this price point
**Weaknesses:**
- Smaller community and ecosystem than Cursor or Devin
- Sharp pricing jump from Pro ($20/mo) to Plus ($100/mo)
**Pricing:** Pro: $20/mo. Plus: $100/mo (Droid Computers). Max: $200/mo. Teams: custom. Enterprise: custom with on-premise. [factory.ai/pricing](https://factory.ai/pricing)
---
### 7. Lovable — Best AI Coding Agent for Non-Technical Founders Building MVPs
Lovable builds React + Supabase apps from a text description in real time — no terminal, no setup, one-click deploy. Built for founders who need a working product without learning a stack.
**Strengths:**
- Zero technical knowledge required — full-stack apps from a description in hours
- Integrated backend: Supabase auth, database, and storage provisioned automatically
- Real-time visual preview as code generates
**Weaknesses:**
- Stack lock-in: React + Supabase only; no framework flexibility
- No ongoing agent — Lovable's role ends at deployment
**Pricing:** Free (30 credits/mo). Pro: $25/mo. Business: $50/mo (SSO, team workspace). Enterprise: custom. [lovable.dev/pricing](https://lovable.dev/pricing)
---
### 8. Replit Agent — Best AI Coding Agent for Beginners and No-Code Prototyping
Replit Agent is entirely browser-based: describe an app or upload a screenshot and Replit selects the stack, builds, and deploys — zero local setup. The screenshot-to-app feature differentiates it from text-only competitors.
**Strengths:**
- Zero setup, browser-native — works on any device including mobile
- Screenshot-to-app: upload a design reference and Agent replicates the interface
- Up to 10 parallel Agent sessions on Pro
**Weaknesses:**
- Vendor lock-in: migrating off Replit's infrastructure is non-trivial
- Generated code often needs refactoring before meeting production standards
**Pricing:** Free (Starter). Core: $25/mo (2 agents). Pro: $100/mo (10 agents). Enterprise: custom. [replit.com/pricing](https://replit.com/pricing)
---
### 9. v0 — Best AI Agent Platform for Frontend and React/Next.js Developers
v0 is Vercel's AI UI generator: production-ready React/Next.js with Tailwind CSS — real component architecture and idiomatic conventions, not throwaway prototypes. Design Mode bridges visual editing and code; one-click deploy to Vercel closes the loop.
**Strengths:**
- Best React/Next.js code quality: real components, accessibility, idiomatic Tailwind
- Design Mode enables visual editing without writing code
- Tightest Vercel ecosystem integration: GitHub sync, AI SDK compatibility, instant deploy
**Weaknesses:**
- Frontend-heavy — weaker on complex backend logic or multi-service architecture
- No ongoing agent: generates on demand, no post-deployment automation
**Pricing:** Free ($5/mo credit, 7 messages/day). Team: $30/user/mo. Business: $100/user/mo (training opt-out). Enterprise: custom. [v0.dev/pricing](https://v0.dev/pricing)
---
### 10. MGX (Atoms) — Best AI Agent Platform for Full-Stack Founder Launches
MGX rebranded to Atoms (atoms.dev) mid-2025; both names remain in circulation. Atoms deploys a multi-agent team — researcher, architect, PM, engineer, SEO specialist, ads agent — collaborating from idea through launch. No other platform here makes SEO and paid acquisition first-class agent roles.
**Strengths:**
- Multi-agent team simulation: specialized roles rather than a single generalist
- SEO and Ads agents extend the platform beyond building into acquiring customers
- Academic foundation: ~30 published papers at ICLR, NeurIPS, and ACL
**Weaknesses:**
- Brand confusion: the MGX → Atoms rebrand creates discovery friction
- Thin enterprise story: no meaningful SSO, admin controls, or audit trails
**Pricing:** Free (25 credits/mo). Pro: $20/mo ($15.80/mo annual, 100 credits/mo). Max: $100/mo (500 credits/mo + Race mode). [atoms.dev/pricing](https://atoms.dev/pricing)
---
## Best AI Agent Platform by Use Case
The best AI agent platform depends on what your team actually needs to accomplish. Here's the direct answer for each common scenario.
| Use Case | Best Pick | Why |
| --------------------------- | ------------- | ------------------------------------------------------------------------- |
| Solo indie dev | Cursor | Best IDE integration, largest community, free tier |
| Startup team (2–10 people) | Duet + Cursor | Duet for ops/automation, Cursor for coding — complementary, not competing |
| Non-technical founder | Lovable | No code required; full-stack app in hours |
| Enterprise engineering team | Devin | Proven at scale, Slack/Linear/GitHub integrations, fleet support |
| Design/UI-focused work | v0 | Production-ready React + Tailwind; Design Mode; Vercel deploy |
| Autonomous ongoing tasks | Duet | Only platform where ongoing ops is the primary value proposition |
---
## How to Choose the Right AI Agent Development Platform for Your Team
The right AI agent development platform fits how your team works. Answer these five questions before signing up.
**1. Do you need the agent to keep working after you log off?**
Local-first tools like Cursor and default Claude Code won't work for always-on use. Duet, Devin, OpenAI Codex, and Factory offer genuine background and scheduled execution — this question eliminates half the list.
**2. Is this an individual tool or a team workspace?**
A shared-workspace model is fundamentally different from isolated agents on individual machines. See [rolling out Claude Code across your team](/guides/claude-code-for-teams) for a reference point on what team adoption actually requires.
**3. What's the technical level of your primary user?**
Developers → Cursor, Claude Code, Factory. Mixed teams → Duet. Non-technical founders → Lovable, Replit Agent, MGX/Atoms. No feature list overcomes a tool-audience mismatch.
**4. Do you have compliance or data privacy requirements?**
Factory (Teams+) and Devin (Enterprise) offer Zero Data Retention; Factory Enterprise adds on-premise. Identify this requirement before you scale past easy-migration territory.
**5. What does AI agent work look like — build or run?**
Most platforms stop at delivery. Duet, Devin, and OpenAI Codex also handle ongoing operations. Teams using AI for sustained operational work saw a [31.8% improvement in PR close time in 2025 (arXiv)](https://arxiv.org/html/2509.19708v1). Be clear about which mode you need.
---
## Frequently Asked Questions About AI Agent Platforms
**What is the best AI agent platform for developers in 2026?**
The best AI agent platform depends on your use case. For teams needing always-on automation and
ongoing operations, **Duet** leads in 2026. For solo developers wanting deep IDE integration,
**Cursor** dominates. For enterprise codebase automation, **Devin** is proven at scale. There is
no single best platform; fit beats features.
**What is the difference between an AI coding agent and a no-code AI builder?**
An **AI coding agent** works inside a developer's codebase — reading files, writing code,
running terminal commands, managing PRs and tests. A **no-code AI builder** (Zapier, Lovable,
n8n) lets non-technical users create automations or apps through a visual chat interface without
writing code. Coding agents work at the code layer; no-code builders abstract it away entirely.
**Which AI agent platforms support team collaboration?**
**Duet** provides a shared human+AI workspace with durable sessions, files, apps, and roles
around the same persistent coworker. **Devin**, **Factory**, and **OpenAI Codex** support team
workflows via Slack, Linear, and GitHub integrations but agents run in isolation. **Cursor** and
**Claude Code** are individual tools with shared billing — a meaningful difference when
evaluating any AI agent development platform.
**Can I run an AI coding agent in the cloud without a local machine?**
Yes. **Duet**, **Devin**, **OpenAI Codex**, **Factory**, **Replit Agent**, **v0**, and
**MGX/Atoms** all run cloud-side with no local machine required. **Cursor** and **Claude Code**
execute locally by default, though you can [run Claude Code in the
cloud](/blog/how-to-run-claude-code-in-the-cloud) without local setup.
**How do AI agent platforms charge — subscription or usage-based?**
Most use flat subscriptions: Cursor Pro ($20/mo), Devin Pro ($20/mo), Claude Code Pro ($20/mo),
Lovable Pro ($25/mo), v0 Team ($30/user/mo). Some add usage overages on top. **Duet** is the
subscription option: Starter, Pro, and Max include monthly credits, with paid-reserve topups for
overage. Monthly credits reset at renewal and do not roll over.
---
_Last updated: June 2026. Pricing and features change frequently — verify directly with each platform before purchasing._
---
Source: https://duet.so/guides/beyond-claude-code-building-a-shared-skill-library
# How to Build a Shared AI Skill Library for Claude Code
*Stop copy-pasting prompts. Learn how to build, share, and maintain an AI agent skill library across Claude.ai, Claude Code, and your entire team.*
By Sawyer Middeleer. Published 2026-02-17, updated 2026-05-08. 24 min read.
You've written the perfect prompt.
It runs your weekly standup summary, builds your PRD in exactly the right format, or generates client reports with the metrics your team actually cares about.
Then someone else on your team needs it. Or you need it in a different tool. Or you want to run it programmatically.
So you copy-paste. You tweak. You copy-paste again.
Six months later, there are nine versions of the same workflow scattered across Slack threads, Google Docs, and half-remembered conversation histories.
Skills solve for this.
This guide will walk you through the full picture — what skills are, where they run, how they differ across Claude's surfaces, and how to build a shared skill library your team can actually maintain.
We'll cover pre-built skills (the fastest path to value), custom skills (packaging your team's expertise), and the patterns that make skills and MCP work together without falling apart.
If you haven't read our earlier guides, here's the quick version: **tools** give Claude access to actions (read a file, call an API), **MCP** standardizes how those tools connect, and **skills** package the _method_ — the instructions, templates, and checks that turn raw tool access into reliable workflows. For the full breakdown, see [Agent Skills 101: Tools vs MCP vs Skills](/guides/agent-skills-101-tools-vs-mcp-vs-skills).
This guide goes deeper on skills specifically.
---
## Why shared skills matter
Every team has tribal knowledge. The way you structure a PRD. The format your investors expect in board decks. The specific checks you run before shipping a deploy. The rubric your team uses for customer research.
This knowledge lives in people's heads, in scattered docs, and in prompts that get rebuilt from scratch every time someone starts a new conversation.
Skills are the packaging layer that turns tribal prompts into reusable capability.
### The problem
_One workflow, ten implementations_
Without skills, here's what happens:
- **Person A** writes a prompt that generates weekly reports in the terminal with Claude Code
- **Person B** rewrites the same prompt in Claude.ai because they don't use the terminal
- **Person C** needs it in their API integration, so they hardcode the instructions into a system prompt
- **Person D** joins the team and starts from zero
Each version drifts. Nobody knows which one is current. When the report format changes, you update one version and forget the others.
### The goal
_Create once, reuse everywhere_
A skill is a directory with a `SKILL.md` file. That's it. The same skill works across:
- **Claude.ai:** for humans who prefer the web interface
- **Claude Code:** for terminal-first workflows and repo-specific context
- **Claude API:** for systems, automations, and product integrations
- **Claude Agent SDK:** for programmatic agent orchestration in TypeScript or Python
One source of truth. Multiple surfaces. When you update the skill, everyone gets the update.
---
## Where skills run
Skills aren't identical everywhere. Each surface has different sharing models, different constraints, and different setup steps.
Understanding these differences is how you avoid building something that only works in one place.
### Quick comparison
| | **Claude.ai** | **Claude Code** | **Claude API** | **Agent SDK** |
| -------------------- | --------------------------- | --------------------------- | ------------------------------ | ------------------- |
| **Pre-built skills** | Yes (automatic) | No | Yes (via `skill_id`) | No |
| **Custom skills** | Yes (upload zip) | Yes (filesystem) | Yes (upload via API) | Yes (filesystem) |
| **Sharing scope** | Per-user only | Per-project or personal | Organization-wide | Per-project |
| **Setup required** | Upload in Settings | Create directory + SKILL.md | API upload + beta headers | Directory + config |
| **Network access** | Varies by settings | Full (your machine) | None (sandboxed) | Full (your machine) |
| **Best for** | Individual use, quick tasks | Repo-specific workflows | Production systems, automation | Custom agent apps |
### Claude.ai
The simplest starting point. Claude.ai supports both pre-built skills and custom skills you upload yourself.
**How to add a custom skill:**
1. Go to Settings: Features
2. Upload your skill as a zip file
3. The skill becomes available in your conversations
**The catch:** Custom skills in Claude.ai are per-user. Your teammate can't see skills you've uploaded. There's no admin panel, no org-wide deployment, no central management. If your team has five people, each person uploads the skill separately.
This matters less than you'd think for personal productivity skills. It matters a lot if you're trying to standardize workflows across a team. For team-wide consistency, use the API or Claude Code with a shared repo.
**Requirements:** Pro, Max, Team, or Enterprise plan with code execution enabled.
### Claude Code
Claude Code is where most builders start with custom skills. Skills live on your filesystem as directories — no upload step, no API calls, no zip files. If you're new to Claude Code, start with [The Ultimate Beginner's Guide](/guides/claude-code-for-founders).
```
.claude/skills/weekly-report/
├── SKILL.md # Main instructions (required)
├── template.md # Report template
└── examples/
└── sample.md # Example output
```
Claude discovers skills automatically and uses them when relevant to your request. Or you invoke one directly with `/weekly-report`.
**Where skills live determines who sees them:**
| **Location** | **Path** | **Who can use it** |
| ------------ | ------------------------------------ | ------------------------------ |
| Personal | `~/.claude/skills/my-skill/SKILL.md` | You, across all projects |
| Project | `.claude/skills/my-skill/SKILL.md` | Anyone working on this project |
| Enterprise | Managed settings | Everyone in your org |
**Key Claude Code features:**
- **Auto-invocation control:** Add `disable-model-invocation: true` to your frontmatter if you only want the skill to run when you explicitly call it (like `/deploy` — you don't want Claude deciding to deploy because your code looks ready)
- **Tool restrictions:** Use `allowed-tools` in frontmatter to limit what Claude can do when a skill is active. `allowed-tools: Read, Grep, Glob` creates a read-only mode
- **Subagent execution:** Add `context: fork` to run a skill in an isolated subagent — useful for research tasks or anything that shouldn't pollute your main conversation context
- **Dynamic context:** The `!command` syntax runs shell commands before the skill content reaches Claude. `!gh pr diff` injects the actual PR diff into the skill prompt
For a practical guide to setting up skills with `CLAUDE.md` and commands, see [The Claude Code Playbook](/guides/claude-code-playbook-building-a-skill-first-workflow-that-actually-sticks#skills-giving-claude-deep-expertise).
### Claude API
The API is where skills become infrastructure. You upload custom skills via the `/v1/skills` endpoint, reference pre-built skills by their `skill_id`, and everything runs in a sandboxed code execution container.
**The differentiator:** Custom skills uploaded via the API are shared organization-wide. Everyone in your workspace can use them. This is the opposite of Claude.ai's per-user model, and it's why the API is the right choice for team-wide standardization.
**Using a pre-built skill (Python):**
```python
import anthropic
client = anthropic.Anthropic()
response = client.beta.messages.create(
model="claude-sonnet-4-6",
max_tokens=4096,
betas=["code-execution-2025-08-25", "skills-2025-10-02"],
container={
"skills": [
{"type": "anthropic", "skill_id": "pptx", "version": "latest"}
]
},
messages=[
{"role": "user", "content": "Create a quarterly review presentation"}
],
tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)
```
**Uploading a custom skill:**
```python
from anthropic.lib import files_from_dir
skill = client.beta.skills.create(
display_title="Weekly Report Generator",
files=files_from_dir("/path/to/weekly-report-skill"),
betas=["skills-2025-10-02"],
)
print(f"Skill ID: {skill.id}")
```
**Important constraints:**
- Requires three beta headers: `code-execution-2025-08-25`, `skills-2025-10-02`, `files-api-2025-04-14`
- No network access inside the container — your skill can't call external APIs
- No runtime package installation — only pre-installed packages are available
- Up to 8 skills per request
- Maximum 8MB upload size per skill
### Claude Agent SDK
The SDK supports custom skills through the same filesystem-based approach as Claude Code. Store skills in `.claude/skills/` and include `"Skill"` in your `allowedTools` configuration.
```tsx
const agent = new Agent({
model: 'claude-sonnet-4-6',
allowedTools: ['Read', 'Write', 'Bash', 'Skill'],
})
```
**One thing to note:** Tool restrictions work differently in the SDK. The `allowed-tools` frontmatter field is a Claude Code CLI feature. In the SDK, you use `allowedTools` in your agent configuration instead.
---
## Pre-built skills via the API
Before you build anything custom, check whether a pre-built skill already does what you need. Anthropic maintains skills for the document types that actual work runs on.
### What you get out of the box
| **Skill ID** | **What it does** |
| ------------ | -------------------------------------------------- |
| `pptx` | Create and edit PowerPoint presentations |
| `xlsx` | Create spreadsheets, analyze data, generate charts |
| `docx` | Create and edit Word documents |
| `pdf` | Generate formatted PDF documents and reports |
These exist because real work produces real artifacts — decks, spreadsheets, docs — not just chat text. If your workflow ends with "now copy this into Google Slides," a pre-built skill can skip that step entirely.
### The practical unlock
Think about the deliverables your team produces repeatedly:
- **Board deck generation** — `pptx` skill takes structured data and produces a formatted presentation
- **Monthly KPI pack** — `xlsx` skill creates a spreadsheet with charts and conditional formatting
- **PRD or spec generator** — `docx` skill outputs a formatted document ready to share
- **Client-ready reports** — `pdf` skill produces polished PDFs
The pattern is the same: structured inputs go in, formatted files come out. The Files API handles uploads and downloads.
**Downloading a generated file:**
```python
for file_id in extract_file_ids(response):
file_metadata = client.beta.files.retrieve_metadata(
file_id=file_id, betas=["files-api-2025-04-14"]
)
file_content = client.beta.files.download(
file_id=file_id, betas=["files-api-2025-04-14"]
)
file_content.write_to_file(file_metadata.filename)
```
### When to build vs. when to use pre-built
**Use pre-built skills when:**
- Output format is standard (pptx, xlsx, docx, pdf)
- You want speed and reliability over custom formatting
- You don't need deep domain-specific logic in the generation
**Build custom when:**
- You need a specific template, structure, or rubric
- The workflow involves multiple steps with validation
- You're combining document generation with domain logic (your DCF model, your brand guidelines, your compliance checks)
You can also combine both — use a custom skill for the analysis logic and a pre-built skill for the final output:
```python
response = client.beta.messages.create(
model="claude-sonnet-4-6",
max_tokens=4096,
betas=["code-execution-2025-08-25", "skills-2025-10-02"],
container={
"skills": [
{"type": "anthropic", "skill_id": "xlsx", "version": "latest"},
{"type": "custom", "skill_id": dcf_skill.id, "version": "latest"},
]
},
messages=[
{"role": "user", "content": "Run the DCF analysis and output to Excel"}
],
tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)
```
---
## Custom skills: packaging your team's expertise
Pre-built skills handle standard formats. Custom skills handle everything else — the workflows, conventions, and institutional knowledge that make your team's work distinct.
### What a custom skill actually is
A skill is a directory. The only required file is `SKILL.md`. Everything else is optional.
```
incident-report/
├── SKILL.md # Main instructions (required)
├── template.md # Your incident report template
├── severity-rubric.md # How to classify severity
├── examples/
│ └── sample-report.md # A good example report
└── scripts/
└── validate.py # Script to check completeness
```
`SKILL.md` uses YAML frontmatter for metadata and markdown for instructions:
```yaml
---
name: incident-report
description: Generates incident postmortem reports following our team format.
Use when writing incident reports, postmortems, or analyzing outages.
---
# Incident Report Generator
## Process
1. Gather timeline from provided logs or description
2. Classify severity using severity-rubric.md
3. Fill in template.md with structured findings
4. Run validation: python scripts/validate.py report.md
5. If validation fails, fix issues and re-validate
## Key rules
- Every finding must cite a specific log entry or timestamp
- Action items must have an owner and a due date
- Never classify severity below the actual impact
```
### Why custom skills exist
They encode "how we do this here":
- **Your PRD structure** — not a generic PRD, but the sections your team actually uses, the questions stakeholders always ask, the format your PM expects
- **Your incident postmortem format** — the specific timeline format, the severity rubric your on-call team agreed on, the action item template that actually gets followed up
- **Your launch checklist** — the 47 things that need to happen before you ship, including the three that everyone forgets
- **Your customer research rubric** — how to synthesize interview notes into the format your product team reads
Without skills, this knowledge lives in "ask Sarah, she knows the format" or "check the wiki page from 2024 that might still be accurate."
### The key design lever: descriptions that trigger correctly
The `description` field is the most important thing you write. It's not documentation for humans — it's metadata Claude uses to decide when to load a skill without loading everything into context.
**Good description:**
```yaml
description: Generates incident postmortem reports following our team format.
Use when writing incident reports, postmortems, or analyzing outages.
```
**Bad description:**
```yaml
description: Helps with documents
```
Include: what it does + when to use it + trigger phrases a user might naturally say. Write in third person ("Generates reports" not "I can help you generate reports").
**Testing your description:** After creating a skill, test it by asking Claude for things the skill should handle. Ask using different phrasings — obvious ones and paraphrased ones. Also test that it _doesn't_ trigger on unrelated requests. A skill that activates too often is almost as bad as one that never activates.
### How progressive disclosure keeps context lean
Skills use a three-level loading system that keeps your context window clean:
| **Level** | **When loaded** | **Token cost** | **What it includes** |
| ---------------- | ----------------------- | --------------------- | ----------------------------------------- |
| **Metadata** | Always (at startup) | ~100 tokens per skill | `name` and `description` from frontmatter |
| **Instructions** | When skill is triggered | Under 5K tokens | SKILL.md body |
| **Resources** | As needed | Effectively unlimited | Additional files, scripts, templates |
This means you can install dozens of skills without penalty. Claude sees the metadata for all of them at startup (lightweight), reads the full SKILL.md only when relevant (moderate), and accesses supporting files only when needed (on demand).
**Practical implication:** Don't try to cram everything into SKILL.md. Keep it under 500 lines. Move detailed reference material, examples, and data into separate files and reference them:
```markdown
## Additional resources
- For API details, see reference.md
- For usage examples, see examples.md
```
Claude reads those files only when the task requires them.
### Security: treat skills like code
Skills provide Claude with instructions and executable code. A malicious skill can direct Claude to do things that don't match its stated purpose.
- **Only use skills from trusted sources** — skills you built or obtained from Anthropic - **Audit
third-party skills thoroughly** — review every file, look for unexpected network calls or file
access patterns - **Review skills in PRs** — same process as code review - **Version and own
them** — every skill should have a clear owner and a changelog
**YAML frontmatter constraints (enforced by the system):**
- `name`: max 64 characters, lowercase letters/numbers/hyphens only, no XML tags
- `description`: max 1024 characters, no XML tags
- Reserved words "anthropic" and "claude" cannot appear in the name
**The supply chain risk is real.** Snyk's ToxicSkills research found 36% of AI agent skills on public directories contain security flaws. Stick to skills from known sources with visible maintainers. This isn't theoretical — there have been active malicious payloads disguised as legitimate skills in public skill directories.
---
## Skills + MCP
If you read our [Agent Skills 101 guide](/guides/agent-skills-101-tools-vs-mcp-vs-skills), you know the core distinction: MCP gives you access, skills give you method. Together, they're more reliable than giant prompts stitched together with ad-hoc integrations.
### Why the separation matters
**MCP** = standardized access to tools and data. It's the plumbing — connecting Claude to Jira, Slack, BigQuery, GitHub, your database, whatever.
**Skills** = reusable workflows. The method, templates, and checks that turn raw tool access into something consistent and reliable.
**Together:** less brittle than ad-hoc integrations. When you change your ticketing system from Jira to Linear, you swap the MCP server. The skill that generates your weekly exec summary stays the same because it defines the _process_, not the _plumbing_.
For a practical walkthrough of connecting MCP tools to your workflow, see [Connecting External Tools with MCP](/guides/claude-code-playbook-building-a-skill-first-workflow-that-actually-sticks#connecting-external-tools-with-mcp).
### The pull, transform, produce pattern
Most useful skills follow the same three-step pattern:
1. **Pull** — MCP tools fetch raw inputs (tickets, docs, metrics, logs)
2. **Transform** — Skill applies method (rubric, formatting rules, validation checks)
3. **Produce** — Pre-built document skill emits the final artifact (pptx, xlsx, docx, pdf) when a formatted file is the desired output
### Practical examples
**Pull:** Jira MCP — get sprint tickets + status changes. Slack MCP — get key thread summaries.
**Transform:** Weekly report skill — normalize data, apply template, highlight blockers.
**Produce:** docx skill — formatted Word document ready for stakeholders.
**Pull:** BigQuery MCP — get revenue, churn, NPS metrics. Stripe MCP — get payment data and trends.
**Transform:** Board deck skill — aggregate metrics, create narratives, flag anomalies.
**Produce:** pptx skill — formatted PowerPoint with charts.
**Pull:** Datadog MCP — get relevant logs and timeline. PagerDuty MCP — get incident timeline and responders.
**Transform:** Incident report skill — structure timeline, classify severity, validate findings.
**Produce:** docx + pdf skills — formatted report for internal review and external stakeholders.
### Referencing MCP tools in skills
When your skill uses MCP tools, always use fully qualified names to avoid "tool not found" errors:
```markdown
Use the Jira:get_sprint_issues tool to retrieve current sprint tickets.
Use the Slack:get_channel_messages tool to pull key thread updates.
```
The format is `ServerName:tool_name`. Without the server prefix, Claude may fail to locate the tool, especially when multiple MCP servers are available.
---
## Efficiency and privacy: code execution with MCP
As your team connects more MCP servers, a scaling problem emerges. This section covers the pattern Anthropic recommends for keeping things fast and cost-effective.
### The scaling problem
When an agent has access to hundreds of MCP tools, two costs explode:
1. **Tool definitions overload the context window:** every tool's name, description, and parameter schema has to fit in context. Hundreds of tools means thousands of tokens spent before Claude processes a single message.
2. **Intermediate results bloat tokens:** when Claude calls a tool that returns a large document, that entire result enters the context window. If the next step involves another tool call, the large result stays in context, burning tokens and slowing responses.
### The recommended pattern: treat MCP tools like code APIs
Anthropic's efficiency guidance: use code execution so the agent can process large intermediate results _inside_ the execution environment and return only the small final result to the model.
Instead of this (expensive):
```
Claude → MCP tool → [large result enters context] → Claude reasons →
MCP tool → [another large result enters context] → Claude generates final answer
```
Do this (efficient):
```
Claude → code execution [
→ load only needed tool definitions via filesystem
→ call MCP tool
→ process large result locally
→ extract relevant data
] → small final result enters context → Claude generates answer
```
### Why teams should care
- **Less latency and cost:** large intermediate results never enter the context window
- **More robust workflows:** less "copy huge blob into next tool call" failure modes
- **Better scaling:** adding more MCP servers doesn't proportionally increase context consumption
This pattern is especially relevant when combining skills with MCP. Your skill's code can orchestrate MCP calls efficiently inside the execution environment, processing data locally and only surfacing what matters.
---
## Operationalizing skills for a team
Building a skill is the easy part. Keeping a skill library healthy over time — that's where most teams drop the ball. This section covers the operational practices that separate "we tried skills once" from "skills are how we work."
For the founder-level discipline that makes skills stick (memory curation, outcome-based briefs, review loops), see [Duet AI for Founders: Founder Mode as an Operating System](/guides/duet-ai-for-founders).
### Ownership model
Every skill needs:
- **An owner:** someone responsible for keeping it current
- **A version:** so you know what's deployed and what changed
- **A deprecation path:** so old skills don't silently break
Store this in your frontmatter or in a companion metadata file:
```yaml
---
name: weekly-report
description: Generates weekly team report with metrics and highlights.
Use when creating weekly reports or team updates.
---
```
For API-managed skills, versions are auto-generated timestamps. Pin to specific versions in production and use `"latest"` only in development:
```python
# Production: pin version
{"type": "custom", "skill_id": "skill_01Abc...", "version": "1759178010641129"}
# Development: use latest
{"type": "custom", "skill_id": "skill_01Abc...", "version": "latest"}
```
### Review and release process
Treat skills like code:
1. **PR review:** security (does this skill access anything unexpected?) + correctness (does it produce the right output?)
2. **Test on real scenarios:** not synthetic inputs, actual tasks your team runs
3. **Staged rollout:** pilot with one team member, then broader org
4. **For API skills:** manage versions via the Claude Console or API endpoints
### Testing checklist
Before sharing any skill, verify:
**Discovery and triggering:**
- Skill triggers on obvious requests ("generate a weekly report")
- Skill triggers on paraphrased requests ("write up this week's updates")
- Skill does NOT trigger on unrelated requests
- Description is specific enough to avoid false positives
**Functional correctness:**
- Output matches expected format and structure
- Validation steps pass (if the skill includes scripts)
- Works with Haiku, Sonnet, and Opus (if you plan to use across models)
- Supporting files load correctly when referenced
**Integration:**
- MCP tool references use fully qualified names
- Required packages are available in the target environment
- Works end-to-end in the target surface (Claude.ai, Code, API)
**Post-packaging:**
- Zip file structure is correct (for Claude.ai or API upload)
- Skill still works after re-upload
- Team members can access it (check sharing scope)
### Documentation pattern that compounds
The strongest skill libraries share a common pattern: the skill IS the documentation. When your skill includes clear instructions, templates, and examples, you don't need a separate wiki page explaining "how to generate a weekly report." The skill itself is the living doc.
To accelerate this:
- **Host your skill repo publicly** (or internally via Git) so skills are discoverable
- **Use consistent naming:** gerund form works well — `generating-reports`, `reviewing-code`, `analyzing-data`
- **Cross-reference related skills** in each SKILL.md: "For data analysis, see the `analyzing-metrics` skill"
### When things go wrong
Common failure modes and fixes:
| **Problem** | **Likely cause** | **Fix** |
| -------------------------------------------- | ------------------------------------------- | ------------------------------------------------------------ |
| Skill never triggers | Description too vague | Add specific trigger phrases and keywords |
| Skill triggers on everything | Description too broad | Narrow the description, add constraints |
| Output format drifts | Instructions too loose | Add a strict template with explicit structure |
| Skill works in Claude Code but fails via API | Network or package dependency | Remove external API calls; verify packages are pre-installed |
| Context window fills up | SKILL.md too long or too many skills loaded | Split into separate files; keep SKILL.md under 500 lines |
---
## The broader ecosystem: skills beyond Claude
Skills aren't just a Claude feature anymore. They're becoming a cross-platform standard, and this has implications for how you invest in your skill library.
### The Agent Skills open standard
Claude Code skills follow the Agent Skills open standard ([agentskills.io](https://agentskills.io)), which works across multiple AI tools. This means a skill you write for Claude Code can potentially work in other tools that support the standard — Cursor, Codex, OpenCode, and others.
### Vercel's skills.sh directory
In January 2026, Vercel launched [skills.sh](https://skills.sh), an open directory where developers publish and install skills for AI agents. It's growing at roughly 147 new skills per day and supports Claude Code, Codex, Cursor, and other tools. Think of it as npm for agent skills.
### Security considerations for public skills
The ecosystem is young, and the supply chain risks are real. Snyk's research found active malicious payloads in public skill directories — skills disguised as crypto trading tools that actually steal credentials.
- Stick to skills from known repositories with visible maintainers - Always audit before enabling
— read every file, not just SKILL.md - For your own team's skills, keep them in a private repo
with code review - When you do publish skills publicly, include clear documentation and your
maintenance commitment
---
## What to build first
If you're starting from scratch, here's a practical sequence:
1. **Pick one workflow your team repeats weekly.** The weekly standup summary. The sprint review prep. The client report. Something everyone does, that everyone does slightly differently.
2. **Build it as a Claude Code skill first.** Filesystem-based, no API setup required. Test it with your own work for a week.
3. **Share it as a project skill.** Commit `.claude/skills/your-skill/` to your repo. Now everyone on the project has it.
4. **If it works, promote it to the API.** Upload via `/v1/skills` so it's available organization-wide and accessible from automations.
5. **Add MCP connections as needed.** Start with the skill logic first. Layer in MCP data sources once the workflow is proven.
Don't try to build a comprehensive skill library on day one. Build the one skill that saves the most time this week. Then build another one next week. The library grows from actual usage, not from planning sessions.
---
## Assets: Skill spec template and governance checklist
### Skill spec template
Use this template for every new skill. It forces you to define scope, inputs, guardrails, and success criteria before writing instructions.
```markdown
# Skill Spec: [Skill Name]
## Scope
- **What this skill does:** [one sentence]
- **What this skill does NOT do:** [boundaries]
- **Target surfaces:** [Claude.ai / Claude Code / API / SDK]
## Inputs
- **Required:** [what the user must provide]
- **Optional:** [what enhances the output]
- **MCP dependencies:** [which MCP servers/tools, if any]
## Guardrails
- **Must always:** [non-negotiable rules]
- **Must never:** [hard constraints]
- **Validation:** [how to verify the output is correct]
## Success criteria
- Output matches expected format
- Triggers on relevant requests
- Does NOT trigger on unrelated requests
- Tested with Haiku / Sonnet / Opus
- Reviewed by [owner name]
## Owner
- **Created by:** [name]
- **Version:** [x.y]
- **Last updated:** [date]
```
### Skill library governance checklist
For teams managing more than a handful of skills:
**Inventory:**
- All skills tracked in a central registry (repo directory or spreadsheet)
- Each skill has a named owner
- Each skill has a version and last-updated date
- Unused skills identified and marked for deprecation
**Quality:**
- New skills require PR review before merging
- Skills tested on real scenarios (not just synthetic inputs)
- Descriptions reviewed for trigger accuracy
- Security audit for any skill that executes code
**Maintenance:**
- Skills reviewed quarterly for accuracy
- Deprecated skills removed or archived (not left to rot)
- Breaking changes communicated to users before deployment
- Version pinning used in production API integrations
**Distribution:**
- Personal vs. project vs. org-wide scope is intentional for each skill
- API-uploaded skills have documented version history
- Claude.ai users know how to install team skills (until org-wide sharing ships)
- New team members know where to find and how to use the skill library
---
## Wrapping up
Skills are the difference between "Claude is useful when I prompt it right" and "Claude knows how our team works."
The investment is small. A SKILL.md file with your team's conventions. A few templates. Maybe a validation script. The return compounds every time someone on your team avoids rebuilding a workflow from scratch.
Start with one. The one workflow you're most tired of re-explaining.
---
_This is Part 3 of the Duet Guides series. Part 1 covers [Agent Skills 101: Tools vs MCP vs Skills](/guides/agent-skills-101-tools-vs-mcp-vs-skills), and Part 2 covers [The Ultimate Beginner's Guide to Claude Code](/guides/claude-code-for-founders). For practical setup of CLAUDE.md, commands, and skills in Claude Code, see [The Claude Code Playbook](/guides/claude-code-playbook-building-a-skill-first-workflow-that-actually-sticks)._
---
Source: https://duet.so/guides/claude-code-for-founders
# Claude Code for Business & Founders: Automate GTM & Ops
*Replace your $5k/mo automation stack. Learn how non-technical founders use Claude Code to automate marketing, product, and operations workflows.*
By Sawyer Middeleer. Published 2026-01-21, updated 2026-02-23. 11 min read.
You're probably spending $5k+ per month on automation tools—Zapier, Clay, n8n, and god knows what else. Claude Code can replace most of that stack for $100-200/month. Most people don't know this, but Claude Code is actually a general agent, not just a coding tool. If only your engineers are using it, you're leaving thousands on the table.
**Quick Summary**
Non-technical founders can ship software MVPs using Claude Code by describing requirements in plain English in the terminal. Claude Code autonomously writes, tests, and deploys code. Most founders go from idea to deployed product for under $50 in API costs.
Running your entire business with Claude Code means using it across three pillars: **go-to-market**, **product**, and **operations**. On the GTM side, you can automate market research, contact enrichment, and copywriting—the stuff you'd normally outsource or pay expensive SaaS tools to do. For product, you can get your whole team shipping features, not just engineers. And for operations, Claude becomes your Chief of Staff—handling email, scheduling, CRM updates, and the hundred other tasks that eat your week.
The process is the same everywhere: map a workflow, turn it into a skill or subagent, test, refine. Here's how to apply it across your entire business.
---
## How to automate marketing with Claude Code
Automate marketing with Claude Code by building skills for market research (Reddit, X, YouTube), contact enrichment (replacing Clay at a fraction of the cost), and copywriting in your brand voice. No engineering support needed — any team member can set up these workflows in minutes.
Marketing teams either wait on engineering for custom tooling or pay through the nose for platforms like Clay, Sprout, and Jasper. Claude Code breaks that tradeoff. Here are three workflows you can build yourself—each one turns hours of manual work into minutes.
### Use Claude Code for market research
Most market research is manual and slow—scrolling through Reddit, skimming competitor mentions, watching YouTube reviews. Claude Code does this in minutes and synthesizes what it finds into actionable insights.
1. **Reddit:** Search 3-5 relevant subreddits for pain points your product can solve, then get messaging recommendations based on how people actually talk about the problem.
2. **X:** Search keywords and competitor names, surface volume trends, and flag spikes in conversation.
3. **YouTube:** Find review videos for your category, pull comments, and analyze sentiment to see what people love and hate.
The output delivers a report you can act on.
### Enrich contacts with Claude Code
Clay charges $150-500+/month for contact enrichment. Claude Code plus a cheap API like Apollo or Clearbit does the same thing for a fraction of the cost.
Connect your CRM via [MCP](/guides/claude-code-playbook-building-a-skill-first-workflow-that-actually-sticks#connecting-external-tools-with-mcp), point Claude at a list of contacts or companies, and let it fill in the gaps—emails, titles, company size, LinkedIn URLs. You can also add custom enrichment: have Claude research each company's tech stack, recent funding, or open job postings. No GTM engineering required.
### Write copy in your voice with Claude Code
Everyone can smell generic AI copy from a mile away. The fix is pretty straightforward: give Claude examples of your actual writing and a prompt that captures your style.
Claude Code makes this easy to systematize. Create a subagent that analyzes your writing samples and extracts your voice—sentence length, vocabulary, tone. Then build a skill that pulls the right samples depending on what you're writing: punchy for social, detailed for blog posts, precise for technical docs. Once it's set up, you get first drafts that sound like you wrote them.
These workflows share a pattern: they touch multiple tools, they'd normally need engineering support, and now anyone on your team can build them. To learn how to package and share these workflows across your team, see [Beyond Claude Code: Building a Shared Skill Library](/guides/beyond-claude-code-building-a-shared-skill-library).
---
## How to get your entire team shipping with Claude Code
Non-technical team members — PMs, sales, support — can use Claude Code to turn customer feedback into working prototypes in hours. Set up a Claude-friendly codebase with a CLAUDE.md file, tuned skills, and review guardrails. Your CS lead can prototype a fix; your sales rep can build a custom demo.
The people closest to your customers—PMs, sales, support—are usually the last ones who can act on what they learn. They hear feedback, file a ticket, and wait weeks for engineering to prioritize it.
Claude Code closes that gap. Non-technical people can now translate customer feedback into working prototypes in hours, not weeks. Some call it vibe coding. The point is the feedback loop gets radically shorter.
This doesn't mean chaos. Set up guardrails so nothing ships without review—but remove the gates that stop people from building in the first place. Your CS lead should be able to prototype a fix for a common complaint. Your sales rep should be able to spin up a demo that addresses a recurring objection.
To make this work, your codebase needs to be Claude-friendly:
- A detailed [CLAUDE.md file](/guides/claude-code-playbook-building-a-skill-first-workflow-that-actually-sticks#claudemd-your-projects-instruction-manual) that explains your project structure, conventions, and gotchas
- [Skills and subagents](/guides/agent-skills-101-tools-vs-mcp-vs-skills) tuned to your libraries and frameworks
- MCP tools for git and ticket management so nothing ships without review
---
## How to turn Claude into your Chief of Staff
Turn Claude Code into your AI Chief of Staff by connecting email, calendar, and CRM via MCP. Claude handles inbox triage, meeting prep, scheduling, CRM updates, and document organization — buying back 10-20 hours per week of operational overhead.
Claude Code for business operations starts here. You might not be able to afford a Chief of Staff, but you probably need one. The operational overhead—email, scheduling, CRM updates, document organization—eats 10-20 hours a week. That's time not spent on product, customers, or fundraising.
Claude Code can handle most of it. Not perfectly, but well enough to buy back significant hours every week.
### Automate email and scheduling with Claude Code
Start by connecting your email, calendar, and drive via MCP. Once connected, try the basics: reading and drafting emails, scheduling meetings, organizing files into folders. These simple automations save hours per week on their own.
From there, build specialized subagents and skills to handle more complex workflows. Think about the manual tasks you repeat daily—inbox triage, meeting prep, follow-up reminders. Each one is a candidate for automation.
### Manage your CRM with Claude Code
Most CRM workflows are already automated, but the ad hoc stuff—one-off updates, weird edge cases, manual data fixes—still happens by hand. Claude Code handles these better than rigid tools like n8n or Make. Connect your CRM via MCP and stop wrestling with filters.
---
## How to automate any workflow
Automate any business workflow with Claude Code in 5 steps: map the process as you would for a new hire, build the automation in plan mode, test end-to-end, refine based on mistakes, and iterate until reliable. Most automations take 2-3 iterations to get right.
Everything above follows the same pattern. Once you see it, you can apply it to any workflow in your business—not just the examples here.
Most automations take 2-3 iterations to get right. Here's the process:
1. **Map the process.** Pick something discrete and write it down—the same instructions you'd give a new hire.
2. **Build the automation.** Open Claude Code in plan mode and ask it to translate your SOP into skills and subagents.
3. **Test it end-to-end.** Run the full workflow with your new skills and subagents.
4. **Refine based on mistakes.** Note where Claude stumbles, feed those notes back, and ask for revisions.
5. **Repeat until reliable.** Keep iterating on steps 3-4 until the workflow runs smoothly.
---
## FAQ
**What is Claude Code?**
Claude Code is an agentic coding tool made by Anthropic that runs in your terminal. It
understands your entire codebase and can write, edit, and execute code autonomously — allowing
non-technical founders and beginners to ship software projects without a CS degree.
**How do I get started with Claude Code as a beginner?**
To get started with Claude Code as a beginner: (1) Install Claude Code using the installer for
your platform, (2) Open your terminal and run 'claude', (3) Navigate to your project folder or
create a new one, (4) Describe what you want to build in plain English. No prior coding
experience is required.
**Do I need a CS degree to use Claude Code?**
No. Claude Code is specifically designed to allow non-technical users — including founders,
marketers, and product managers — to build and ship real software. You describe what you want in
plain English and Claude Code writes the code for you.
**How can non-technical founders use Claude Code to build products?**
Non-technical founders can use Claude Code by describing their product requirements in plain
English directly in the terminal. Claude Code reads your project files, writes code, runs tests,
and deploys — no programming knowledge required. Most founders ship their first working
prototype within 30 minutes.
**What is the best AI coding tool for startup founders in 2025?**
Claude Code by Anthropic is widely considered one of the best AI coding tools for non-technical
startup founders. It works directly in your terminal, understands your full codebase, and can
autonomously write, test, and deploy code based on plain English instructions.
**How much does it cost to build a startup MVP with Claude Code?**
Building an MVP with Claude Code typically costs $10-50 in API fees for a basic web application.
Claude Code uses the Anthropic API, billed per token. Most founders spend less than $100 to go
from idea to a fully functional, deployed MVP.
**Do I need to know how to code to use Claude Code?**
No. If you can organize files and write clear instructions, you can use Claude Code. The
examples in this guide—market research, contact enrichment, email automation—require no
programming.
**What subscription do I need?**
Claude Code requires Claude Pro ($20/month) or Claude Max ($100-200/month). Pro is enough for
most workflows. Max gives you higher usage limits for heavy automation.
**What is MCP?**
MCP (Model Context Protocol) connects Claude Code to external tools like your CRM, email,
calendar, or Google Sheets. It's what lets Claude take action in those apps, not just talk about
them.
**Can Claude Code replace Zapier or Clay?**
For many workflows, yes. Claude Code handles complex, multi-step automations that would require
expensive plans on traditional platforms. The tradeoff is more setup upfront, but far more
flexibility.
**What are skills and subagents?**
Skills are reusable prompts that tell Claude how to do a specific task. Subagents are
specialized Claudes you spin up for particular jobs—like a research agent or a writing agent.
Both help you build reliable, repeatable workflows. Learn more in our [Agent Skills 101
guide](/guides/agent-skills-101-tools-vs-mcp-vs-skills).
**Is it safe to let AI work on my codebase?**
With guardrails, yes. Use permission modes, require review before anything ships, and start with
low-stakes workflows. Claude Code won't push to production unless you let it.
## Keep reading
- [Duet AI for Founders: Founder Mode as an Operating System](/guides/duet-ai-for-founders). Run a company in Founder Mode with AI agents instead of middle management.
- [Agent Skills 101: Tools vs MCP vs Skills](/guides/agent-skills-101-tools-vs-mcp-vs-skills) — understand the building blocks of AI agent workflows.
- [Building a Shared Skill Library](/guides/beyond-claude-code-building-a-shared-skill-library) — create reusable skills your whole team can use.
- [How to Run Claude Code in the Cloud](/blog/how-to-run-claude-code-in-the-cloud) — set up persistent Claude Code sessions that run 24/7.
- [How to Use AI to Run Startup Operations](/blog/how-to-use-ai-to-run-startup-operations-with-a-3-person-team) — practical playbook for lean teams.
---
Source: https://duet.so/guides/claude-code-for-teams
# Claude Code for Teams: The Complete Setup Guide for 2026
*The deployment runbook for rolling out Claude Code across a team — plan structure, shared CLAUDE.md, Skills, MCP, Subagents, onboarding, and measuring ROI. Plus the five rollout mistakes to avoid.*
By Duet Team. Published 2026-05-18. 27 min read.
**Quick Summary**
Claude Code is built for individuals. Making it work for a team requires deliberate setup: choosing the right plan structure, sharing CLAUDE.md and Skills via git, configuring MCP servers with scoped credentials, onboarding new hires in 30 minutes, and measuring five metrics quarterly. This guide is the deployment runbook — covering plan selection, shared configuration, onboarding checklists, ROI measurement, and the five rollout mistakes that quietly kill team adoption.
---
Claude Code is built around a single developer.
The docs assume you. The defaults assume you. The pricing pages assume you.
But the moment Claude Code stops being one engineer's secret weapon and starts being something a team relies on — five developers, ten, fifty — every assumption shifts, and a lot of teams discover the gap the hard way.
The hard way looks like every developer maintaining their own **CLAUDE.md**. Skills get copy-pasted across Slack messages. One person installs a sketchy MCP server with broad credentials and nobody notices. New hires spend their first week piecing together someone else's setup from screenshots. Your $200/month Max subscriptions don't pool, so one developer hits limits at 2pm Friday while another's quota sits idle. AP wants one invoice; you've got eight separate Anthropic charges from eight different cards.
None of this is anyone's fault. It's the natural state of a tool designed for individuals being used by a team. The fix is setting up **Claude Code for teams** as a shared primitive from day one.
This guide is the deployment runbook. We'll cover how to choose the right plan structure (and when [individual subscriptions stop making sense](/blog/claude-code-pricing)), how to share CLAUDE.md, Skills, MCP servers, and Subagents across the team, the day-one onboarding checklist for new hires, how to measure whether Claude Code is actually working, and the common rollout mistakes that quietly kill team adoption.
Whether you're a 3-person startup, a 30-person engineering org, or an agency rotating across client codebases, the playbook is the same. Read it once, set it up well, and you'll spend the next year shipping with Claude Code instead of configuring it.
## Why teams adopt Claude Code differently from individuals
The shift from solo Claude Code to team Claude Code lies in changing what you're optimizing for. A solo developer optimizes for personal velocity. A team optimizes for consistency, governance, and compounding shared knowledge.
The same primitives work in both modes, but you wire them up completely differently.
Most teams discover this the hard way, three months in, when the same questions keep coming up: _Why is your PR review so much more thorough than mine? Where do I find the migration script you used? Why does Claude give me different code style than what's in the codebase?_
Those aren't Claude Code problems. They're configuration-fragmentation problems. Here's what changes once you cross the line from one developer to a team.
### Individual mode: Claude Code as a personal tool
When one developer uses Claude Code:
- **CLAUDE.md** is whatever helps _them_ navigate the codebase
- Skills are personal preferences ("how I write commits," "my review checklist")
- MCP servers are installed locally, with whatever credentials are handy
- Plan choice is a personal cost decision (Pro vs Max, paid out of pocket or expensed)
- Hooks reflect individual workflow ("auto-format my code," "warn me before pushing")
This works. The only person depending on this configuration is the developer who set it up, and they fix it as they go.
### Team mode: Claude Code as shared infrastructure
When a team uses Claude Code:
- **CLAUDE.md** defines how _anyone_ on the team should navigate the codebase
- Skills encode team standards ("how _we_ write commits," "_our_ review checklist")
- MCP servers need shared configuration, scoped credentials, and audit trails
- Plan choice is a procurement decision with budget approval and a single invoice
- Hooks enforce team-wide policies ("no secret commits," "always run tests," "audit-log every Claude session")
The same building blocks. Completely different configuration model. A skill that's perfect for one developer might be wrong for the team. A Max plan that's great for one heavy user is wasteful when half your team uses Claude Code twice a week.
### The five problems team adoption surfaces
If you've started rolling Claude Code out to your team, you've probably already hit some of these. If you haven't yet, you will:
1. **Configuration fragmentation.** Every developer has a different CLAUDE.md, different installed skills, different MCP servers. Outputs vary wildly because inputs vary wildly.
2. **Knowledge siloing.** Senior engineers' best workflows live in their personal skills folder. New hires reinvent the wheel.
3. **Credential sprawl.** Every developer has their own GitHub token, Postgres credential, and Anthropic API key — often over-scoped, often committed to dotfiles repos.
4. **Cost unpredictability.** Some devs are on Pro, some on Max, some have an `ANTHROPIC_API_KEY` set that silently bypasses their subscription. Finance can't forecast.
5. **No usage visibility.** You don't know which skills are firing, which MCP servers are being used, or whether Claude Code is actually saving time.
These aren't theoretical. They're the same five problems every team has reported in the post-launch period of Claude Code, and they all share one root cause: tooling designed for one person, deployed to many.
### The decision framework
Before any of the technical setup, the team needs to answer four questions:
1. **Who's responsible?** Pick one engineer who owns Claude Code configuration the way a platform engineer owns CI. Without an owner, drift is guaranteed.
2. **What's shared vs personal?** Decide which configuration travels with the team and which stays per-developer. (Hint: most should be shared.)
3. **What's the governance model?** Who approves new Skills, MCP servers, and plugins? How are credentials managed?
4. **What does success look like?** If you can't measure it, you can't optimize it. Decide upfront what "Claude Code working for the team" means in concrete terms.
The next four sections walk through each piece of the actual setup. But none of them work if you skip the four questions above. **Treat Claude Code adoption like any platform rollout — own it, govern it, measure it.** That's the only meaningful difference between teams that succeed with it and teams that don't.
## Choose a Claude Code plan structure for your team
The right plan structure for a team isn't about picking the cheapest tier — it's about matching billing predictability and usage pooling to how your team actually works. Get this wrong and you'll either overpay for unused capacity, hit rate limits during crunch weeks, or both.
This is the first decision because every other piece of team setup depends on it. The plans you pick determine billing, who has access to what models, and whether usage pools across developers or stays siloed per seat.
If you haven't yet, read [our Claude Code pricing breakdown](/blog/claude-code-pricing) — it has the full plan-by-plan comparison and real cost scenarios. This section focuses on the _team_ angle.
### Four subscription options
**Stack individual Pro/Max subscriptions**
Every developer pays for their own Claude Pro or Max plan. AP either expenses each one or hands out company cards.
**Pros:** Simplest to start. Each dev picks the tier that fits their usage. No minimum seat requirement.
**Cons:** No central admin or billing. Usage doesn't pool. Reimbursement headache. No visibility.
**Fit:** Teams of 1-3, or while you're piloting Claude Code before committing.
**Anthropic Team plan (Premium seats)**
Centralized billing, $100/seat/month for Claude Code access (Premium tier), 5-seat minimum.
**Pros:** Single invoice. Centralized admin. Easier procurement.
**Cons:** 5-seat minimum. Each seat has its own limits, no pooling. Light users overpay; heavy users still hit per-seat walls.
**Fit:** Teams of 5+ where everyone uses Claude Code roughly equally.
**Anthropic Enterprise**
Custom pricing, 500K context window, SSO, HIPAA, audit logs.
**Pros:** Compliance and procurement story is clean. Largest context window. Custom terms.
**Cons:** Sales cycle. Minimum spend often higher than $1K/month. Overkill if you don't need compliance.
**Fit:** Healthcare, finance, regulated industries.
**Managed platform (Duet)**
Monthly plans with included credits, one designated owner as payer, a paid reserve for overage, and a shared workspace with durable sessions, Files, Train, and managed Integrations.
**Pros:** Usage pools. Shared workspace. Clear billing owner. Built-in visibility.
**Cons:** Adds a managed layer between you and Anthropic's primitives.
**Fit:** Teams of 3-20 with uneven usage; agencies; teams where rate-limit-roulette is taxing shipping.
### The decision matrix
| Scenario | Best option |
| ------------------------------------------- | ------------------------------------ |
| Piloting with 1-3 devs | Stacked individual Max subscriptions |
| 5+ devs, even usage, central billing needed | Anthropic Team Premium |
| Regulated industry, SSO/HIPAA required | Anthropic Enterprise |
| Uneven usage, want pooling + one invoice | Managed platform (Duet) |
| Agency rotating across client codebases | Managed platform (Duet) |
| Budget predictability is the top priority | Managed platform (Duet) |
### The hidden plan trap to fix on day one
Before you commit to any plan, scan every developer's environment for:
```bash
echo $ANTHROPIC_API_KEY
```
If anything prints, that developer's Claude Code is silently bypassing their subscription and charging the API directly. We've seen teams pay $200/month for Max plans that did nothing because every developer had a leftover API key in their shell profile from when they were experimenting with the Anthropic SDK.
### Cost benchmarks for common team sizes
| Team size | Stacked Max 5x | Anthropic Team Premium | Managed platform |
| ------------- | -------------- | -------------------------- | ---------------- |
| 3 developers | $300/mo | Not available (5-seat min) | $150-300/mo |
| 5 developers | $500/mo | $500/mo | $250-500/mo |
| 10 developers | $1,000/mo | $1,000/mo | $500-800/mo |
| 20 developers | $2,000/mo | $2,000/mo | $800-1,500/mo |
As soon as usage gets uneven across developers, pooled pricing wins on both predictability and absolute cost.
### What to do if you're piloting
If you're not ready to commit to a structure yet:
1. Start with **3-5 individual Max 5x subscriptions** for your most active users.
2. Run for 30 days.
3. Track who hits limits, how often, and which developers barely use it.
4. Use that data to pick the right structure for the rest of the team.
A 30-day pilot will tell you more about your real usage pattern than any spreadsheet projection. Don't lock in pricing until you've measured.
### When to revisit the decision
Plan structure isn't a one-time choice. Revisit it every quarter, or any time one of these triggers fires:
- **Team grows past 5 / 10 / 20.** Each threshold opens new options.
- **Usage pattern changes.** Product launch, agency client onboarding, seasonal crunch.
- **Finance asks for predictability.** Flat-fee structures win when budgeting matters more than flexibility.
- **Compliance shows up.** PHI, PII, SOC 2 — Enterprise becomes the only option.
## Set up shared CLAUDE.md, Skills, MCP, and Subagents
**The single biggest leverage point in team Claude Code adoption is moving from "every developer configures their own setup" to "the team configures one setup that everyone inherits."** Every workflow improvement made by any developer benefits everyone — that's the compounding loop that separates teams that pull ahead with Claude Code from teams that plateau.
### Share CLAUDE.md (start here)
CLAUDE.md is the always-on context file Claude reads at the start of every session in a repo. The easiest thing to share: just commit it.
```
your-repo/
├── CLAUDE.md # <-- committed to git
├── src/
└── package.json
```
**What goes in a team CLAUDE.md:**
- A 2-3 sentence description of what this codebase is
- Build, test, lint, and run commands
- Code style and naming conventions
- Architectural patterns the team has agreed on
- Known gotchas
- Pointers to deeper docs
**What does NOT go in CLAUDE.md:**
- Personal preferences (those go in `~/.claude/CLAUDE.md` or skills)
- Cross-repo company conventions (use a shared skill plugin instead)
- Anything that changes weekly
**Length discipline:** Keep CLAUDE.md under ~300 lines. Every line loads on every session.
### Share Skills (the highest-leverage shared primitive)
Skills are where team knowledge compounds. They encode the _procedures_ that used to live in senior engineers' heads, and once written down once, every developer benefits.
**Three ways to share Claude Code skills:**
**For repo-specific skills: commit them to `.claude/skills/`**
```
your-repo/
├── .claude/
│ └── skills/
│ ├── pr-review-checklist/
│ ├── migration-runner/
│ └── feature-spec-writer/
└── src/
```
**For cross-repo company skills: ship them as a plugin**
```
your-org-plugin/
├── .claude-plugin/plugin.json
└── skills/
├── company-voice/
├── incident-postmortem/
└── code-style/
```
**For teams hitting skill-sprawl: use a managed platform**
When you have 20+ skills across multiple repos, you are spending real time on maintenance. A persistent workspace such as [Duet](/) can keep reusable instructions and scripts in shared files, but teams still need an explicit review and versioning process for those assets.
**The starter library most teams converge on** (covered in detail in [the Skills guide](/guides/claude-code-skills-complete-guide)):
1. **pr-review-checklist** — your team's review standards
2. **commit-message** — your house format for commits
3. **incident-postmortem** — template and tone for retros
4. **feature-spec** — how to write a one-page feature spec
5. **migration-safety** — pre-flight checks for schema changes
6. **code-style** — your unwritten conventions, written down
7. **customer-comms** — voice and templates for customer-facing writing
### Share MCP servers
MCP servers give Claude access to external systems. Sharing them across a team is more sensitive than sharing skills because they run with credentials.
**The scope rule:**
| Scope | Config location | Credential model | Use case |
| -------- | --------------------- | -------------------------- | --------------------------------------------- |
| Personal | `~/.claude/` | Per-developer, local | Note-taking, personal tools |
| Project | `.mcp.json` in repo | Per-developer via env vars | Shared team servers (GitHub, DB, Sentry) |
| User | `~/.claude/.mcp.json` | Per-developer, local | Cross-repo servers the developer always wants |
**Project-scope MCP setup workflow:**
1. The Claude Code owner adds the server with `--scope project`. Config commits to `.mcp.json` in the repo.
2. Each developer provides their own credential via env var. **Never commit credentials.**
3. Document required env vars in the repo's README so new hires know what to set.
**Example shared `.mcp.json`:**
```json
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@anthropic-ai/mcp-server-github"],
"env": {
"GITHUB_TOKEN": "${GITHUB_TOKEN}"
}
},
"postgres": {
"command": "npx",
"args": ["-y", "@anthropic-ai/mcp-server-postgres"],
"env": {
"DATABASE_URL": "${DATABASE_URL}"
}
}
}
}
```
**Credential hygiene checklist:**
- Use **read-only credentials** wherever possible
- Use **fine-grained tokens** with the minimum scopes
- Use **per-developer credentials** — never share one token across the team
- **Rotate** when developers leave
**Servers worth sharing across the team:** GitHub, your primary database (read-only), Sentry/PostHog, Slack or Linear, Context7 for framework docs.
**Servers to keep personal:** Personal note-taking (Notion, Obsidian), anything with broad credential access, experimental servers.
### Share Subagents
Subagents are independent specialists that run with their own context and tools.
```
your-repo/
├── .claude/
│ └── agents/
│ ├── pr-reviewer.md
│ ├── security-auditor.md
│ └── doc-writer.md
└── src/
```
**The subagent worth writing first:** A `pr-reviewer` subagent on Sonnet with read-only file access, applying your team's code-review-checklist skill. It enforces consistency on the most variable team activity.
**Subagent best practices for teams:**
- **Restrict tools by default.** A reviewer subagent should not have `Edit` or `Write`.
- **Pick the right model.** Lookup-heavy subagents on Haiku, reasoning-heavy on Sonnet, complex architecture on Opus.
- **Use isolation when relevant.** Security-review subagent in an isolated worktree.
### The all-in-one option: distribute everything as a plugin
Plugins bundle skills, subagents, MCP configs, and hooks into one installable unit:
```
your-team-plugin/
├── .claude-plugin/plugin.json
├── skills/
├── agents/
├── .mcp.json
└── README.md
```
One install command, version-controlled, easy to update everyone at once.
### Rollout order that actually works
1. **Week 1:** Share CLAUDE.md.
2. **Week 2-3:** Share two or three high-value skills.
3. **Week 4:** Add shared MCP servers.
4. **Month 2+:** Add subagents and bundle into a plugin.
Trying to ship a complete team setup on day one usually means none of it lands. Layered rollout is how you get adoption.
### Who owns the shared library
Two governance basics keep all of the above from drifting:
- **CODEOWNERS.** Add `.claude/` directories and `.mcp.json` to your CODEOWNERS file so changes go through PR review like any other code.
- **One owner.** The Claude Code owner from Step 1 is also the one who merges changes to the shared library. Without an accountable owner, drift is guaranteed.
That's the governance you need. If you grow into compliance requirements, audit logs, or formal change management, Anthropic Enterprise or a managed platform handles those for you.
## Onboarding new hires
The fastest predictor of whether Claude Code will stick at your company is how quickly a new hire becomes productive with it.
A new engineer who's productive on Claude Code in their first week sees it as a force multiplier and uses it forever. A new engineer who spends their first week wrestling with their setup decides it's "not worth it" and writes code the old way.
### The pre-arrival setup
Before the new hire's first day (handled by IT or the manager):
- Add them to the team's Anthropic plan or managed-platform workspace
- Add their GitHub username to the team's plugin repo
- Add them to CODEOWNERS reviewer groups they should be part of
- Provision per-developer credentials for shared MCP servers
This takes 15 minutes and saves the new hire half a day of "waiting for access."
### The 30-minute first-day setup
1. Install Claude Code (CLI, IDE extension, or both)
2. Sign in with the team's auth (SSO if you have it)
3. **Run `echo $ANTHROPIC_API_KEY`. If anything prints, unset it.** This is the single most common cost trap.
4. Install the team plugin (or clone the team's skills/agents repo)
5. Set the env vars for shared MCP servers
6. Run `claude` in the team's main repo. Confirm CLAUDE.md loads, skills appear, MCP servers connect.
7. Run a smoke-test prompt: ask Claude to summarize the codebase.
If any step fails, the new hire pings the Claude Code owner. The owner fixes the docs so the next hire doesn't hit the same issue.
### The first-week workflow tour
A 1-hour walkthrough on day 1 or 2, run by the Claude Code owner or any senior engineer:
1. **Show them the team's Skills.** Demonstrate one in action.
2. **Show them the team's Subagents.** Especially the PR-reviewer.
3. **Show them the team's MCP servers.** One query against the database, one against GitHub.
4. **Show them what NOT to do.** Hooks that block dangerous commands. Past incidents.
5. **Point them at this guide.** And the [Skills guide](/guides/claude-code-skills-complete-guide) and [Pricing post](/blog/claude-code-pricing).
### The first-month milestones
- **Week 1:** They've shipped one PR using Claude Code
- **Week 2:** They've used at least three different team skills
- **Week 3:** They've proposed a tweak to an existing skill or written one of their own
- **Month 1:** Claude Code is a default part of their workflow
The third milestone is the most important — it signals they've crossed from "user of the team's setup" to "contributor to it." That's where the compounding starts.
### Common onboarding failures
1. **Stale docs.** _Fix:_ every new hire updates the doc as they go.
2. **Unwritten institutional knowledge.** _Fix:_ if it isn't in the checklist, it doesn't exist.
3. **Permission gaps.** _Fix:_ IT/manager provisions everything before day 1.
4. **No buddy.** _Fix:_ assign an onboarding buddy for the first week.
5. **No expected workflow.** _Fix:_ be opinionated. Pick one default and document it.
## Measuring Claude Code adoption and ROI
If you can't measure whether Claude Code is working for your team, you can't justify the spend, can't optimize the setup, and can't tell whether the next hire should onboard onto it.
Most teams skip measurement entirely and just trust the vibe. The vibe is wrong about half the time.
### What to measure
Teams roll out Claude Code for three reasons:
- **Velocity:** "We want to ship faster." Measure throughput.
- **Quality:** "We want fewer bugs, more consistency." Measure defect and review metrics.
- **Cost:** "Prove it's worth it." Measure spend per developer and per outcome.
### Top 5 metrics to target
**1. Weekly active developer rate**
What percent of your engineers use Claude Code in a given week? If adoption is below 70%, no other metric matters.
**Target:** 80%+ weekly active rate within 60 days.
**2. Skill activation rate**
Which team skills are actually firing? A skill that never activates is a skill whose description is wrong.
**Target:** Every team skill should activate at least once per week.
**3. PR cycle time delta**
The single best velocity metric for engineering teams.
**Target:** PR cycle time should drop 20-40% within 90 days.
**4. Spend per active developer**
Total Claude Code spend / weekly-active developers.
**Healthy ranges:**
- Solo Max 5x stack: $80-100/active dev
- Anthropic Team Premium: $80-100/active dev
- Managed platform: $40-80/active dev
**5. New-hire time-to-first-PR**
How long until a new hire ships their first PR?
**Target:** New-hire time-to-first-PR should drop 30-50% with good Claude Code onboarding.
### What NOT to measure
- **Lines of code generated by Claude.** Quantity, not quality.
- **Tokens consumed.** Usage isn't outcome.
- **Prompts sent.** Same problem.
- **Developer satisfaction survey scores.** Surveys lag reality.
### 90-day review template
1. What's the active developer rate?
2. Which 3 skills are firing the most?
3. Which 3 skills are firing the least?
4. What's PR cycle time vs 90 days ago?
5. What's spend per active developer?
6. What new skills should we add?
7. What's blocking adoption for the developers who aren't using it?
Run quarterly. The first review is where you'll find 80% of the gaps.
### Communicating ROI up
When your VP or CFO asks "is Claude Code worth what we're paying":
> "We pay X/month. Our PR cycle time dropped Y%, new-hire ramp dropped Z weeks, and the team is at W% weekly active. That's ~N/month in engineering time saved. Net ROI: Mx."
Three numbers, one spend number, one ROI calculation. That's the slide.
### What "working" actually looks like
- 80%+ weekly active rate
- Every team skill firing at least weekly
- PR cycle time down 20-40% from baseline
- New-hire time-to-first-PR down 30-50%
- Spend per active developer in line with benchmarks
- A growing skill library, with most contributions coming from people other than the original Claude Code owner
That last one is the leading indicator that Claude Code has become _team infrastructure_ instead of _one person's project_.
## Common Claude Code rollout mistakes to avoid
Most teams that struggle with Claude Code aren't struggling with the tool — they're making the same five rollout mistakes we've seen on repeat across hundreds of team deployments.
### Skipping the plan audit
The `ANTHROPIC_API_KEY` environment variable trap. Developers set it once when experimenting with the Anthropic SDK, forget about it, then sign up for a Pro or Max plan. Claude Code silently uses the API key, the subscription does nothing, the team gets a surprise $400 API bill on top of $200/month they're already paying.
_Fix:_ Day-one check. `echo $ANTHROPIC_API_KEY` and unset.
### Letting configuration drift
Everyone running their own CLAUDE.md, their own skills, their own MCP servers. Six months in, the team's outputs look like they came from six different companies.
_Fix:_ Commit CLAUDE.md to the repo on day one. Move at least three high-value skills into `.claude/skills/` within the first month.
### Trying to share everything at once
Teams who try to ship CLAUDE.md, skills, MCP servers, subagents, hooks, and a plugin in the first week usually ship none of it.
_Fix:_ Layered rollout. CLAUDE.md week 1. Skills weeks 2-3. MCP week 4. Subagents and plugins month 2.
### No accountable owner
When everyone owns the shared library, nobody does. Skills go stale. MCP servers break. CLAUDE.md drifts out of date.
_Fix:_ One named owner. 1-2 hours a week of their time.
### Measuring nothing
The team rolls out Claude Code, doesn't measure adoption or impact, and a quarter later can't answer "is this working?" Finance pushes back. Adoption stalls. The rollout dies of indifference.
_Fix:_ Set up the five metrics from Step 4 before you roll out, not after.
---
Claude Code is built for one developer.
Making it work for a team is a deliberate setup — not because the tool is hard, but because the defaults assume you're alone.
The teams that pull ahead with Claude Code in 2026 share a pattern. They pick a plan structure deliberately. They share CLAUDE.md, Skills, MCP servers, and Subagents from day one. They have one owner. They onboard new hires in 30 minutes, not three days. They measure adoption with five metrics instead of zero. None of that is rocket science. Most of it is just choosing not to do the ad-hoc thing.
If you take three things from this guide:
1. **Pick the plan structure that matches your usage pattern, not your team size.** Stacked Max subscriptions are fine for 1-3 even-usage devs. Pooled pricing wins for uneven or growing teams.
2. **Share configuration from day one.** CLAUDE.md, then skills, then MCP, then subagents. Layered, not all at once.
3. **Measure five things.** Active rate, skill activations, PR cycle time, spend per active dev, new-hire ramp. Quarterly review.
That's the playbook. Run it once, well, and the next year of shipping happens on top of Claude Code instead of around it.
## Stop paying for Claude Code that your team isn't using
If you're piloting Claude Code with 1-3 developers, stack individual subscriptions and follow this guide as you grow. You don't need a managed platform yet — you need conventions.
But if you're past pilot — a team of 5+, uneven usage, an agency with bursty workloads, or a finance team that wants one predictable invoice — the operational tax of doing this manually starts compounding.
[**Duet**](/pricing) gives your team a shared workspace with pooled usage, durable sessions, shared files and training sources, managed integrations, and the visibility you need to evaluate the work.
[**See Duet for teams →**](/pricing)
## Frequently Asked Questions
### How much does Claude Code cost for a team of 5?
Stacked individual Max 5x subscriptions are $500/month for 5 developers. Anthropic Team Premium is also $500/month (5 seats x $100), with central billing but no usage pooling. [Duet](/pricing) offers Starter, Pro, and Max monthly plans with shared included credits and reserve overage, so compare the current plan catalog with your team's workload.
### How to share CLAUDE.md across a team?
Commit CLAUDE.md to the repo root. Every developer running Claude Code in that repo loads it automatically. Treat changes the same as code changes — through PR review. Add `.claude/` directories and CLAUDE.md to your CODEOWNERS file so the team's Claude Code owner reviews modifications.
### Can Claude Code Team plans share usage across developers?
No. Anthropic Team Premium plans give each seat its own usage limit — they don't pool. One developer can be at their cap while another's quota sits idle. This is one of the main reasons teams with uneven usage move to managed platforms, which do pool usage across the team.
### What's the best way to onboard a new developer to Claude Code?
Three steps: (1) Pre-provision their plan seat, GitHub access, and MCP credentials before their first day. (2) Give them a 30-minute first-day checklist for installation, env-var setup, and a smoke-test prompt. (3) Run a 1-hour walkthrough of the team's Skills, Subagents, and MCP servers in their first week. New hires should ship their first Claude Code PR by end of week 1.
### How to share Claude Code Skills across a team?
Three ways, depending on scope. **Repo-specific skills:** commit them to `.claude/skills/` in the repo. **Cross-repo company skills:** ship them as a plugin in a shared git repo or registry. **Shared workspace playbooks:** keep reviewed instruction files in workspace Files with your own versioning and review process. Start with the first and add coordination only when the library needs it.
### How to share MCP servers across a team safely?
Use project scope (`--scope project`) so the config commits to `.mcp.json` in the repo. Reference credentials via env vars — never commit literal secrets. Provision per-developer credentials (each dev gets their own GitHub token, database user) so offboarding is one-credential rotation. Use least-privilege scopes (read-only DB user, fine-grained tokens) wherever possible.
### What's the most common Claude Code onboarding mistake teams make?
Forgetting to unset `ANTHROPIC_API_KEY`. If a new hire has that environment variable set from prior experimentation with the Anthropic SDK, Claude Code silently uses the API key and bypasses the team's subscription — the team pays for both. Add `echo $ANTHROPIC_API_KEY` to the day-1 checklist; unset if anything prints.
### How to measure if Claude Code is working for my team?
Track five metrics: (1) weekly active developer rate (target 80%+), (2) skill activation rate (every team skill firing at least weekly), (3) PR cycle time delta vs pre-rollout (target 20-40% drop), (4) spend per active developer, (5) new-hire time-to-first-PR (target 30-50% faster). Run a 90-day review using these. Skip vanity metrics like tokens consumed or lines of code generated.
### When should my team graduate from individual subscriptions to a managed platform?
The usual triggers: team grows past 5 developers with uneven usage, finance wants one predictable invoice instead of stacked subscriptions, you're spending real time maintaining shared skills/MCP across multiple developers, you can't tell who's using what, or you've had one Claude Code-related security or cost surprise. If any two are true, you're past the cost-of-doing-it-manually threshold.
### Can you run Claude Code with SSO and audit logs?
Yes, but only on Anthropic Enterprise or managed platforms like Duet. Pro, Max, and Team Premium plans don't include SSO or audit logging. If compliance, procurement, or a security team is involved in your rollout, plan for Enterprise pricing or a managed-platform alternative from the start.
### Does Claude Code work the same across Claude Code, Claude.ai, and the API for a team?
Skills, CLAUDE.md, and the Agent Skills spec work across all three surfaces, so shared skills are portable. MCP servers and subagents are Claude Code-specific. Most teams standardize on Claude Code (CLI + IDE extensions) for engineering work.
### How long does it take a team to fully roll out Claude Code?
It usually takes 3 months. **Week 1:** Plan structure, CLAUDE.md committed, first developers onboarded. **Weeks 2-4:** First three shared skills written, project-scope MCP configured. **Month 2:** Subagents added, library bundled as a plugin. **Month 3:** First 90-day measurement review. By month 3, Claude Code should feel like infrastructure, not a pilot.
---
Source: https://duet.so/guides/claude-code-mcp-servers-setup
# Claude Code MCP Servers: Complete Setup Guide (2026)
*Claude Code MCP servers connect your AI agent to GitHub, Slack, Notion, databases, and more. Step-by-step setup, configuration, and the best MCP servers for coding workflows.*
By Duet Team. Published 2026-05-28. 15 min read.
MCP servers turn Claude Code from a code-completion tool into a connected agent. Instead of pasting data from Slack, Jira, or your database into the chat window, you connect Claude directly to those systems. It reads, writes, and acts on your behalf.
This guide covers everything: how to add MCP servers, which ones matter for coding workflows, how to configure them for your team, and how to debug them when they break. If you are new to MCP as a concept, start with [Skills vs MCP: What's the Difference](/guides/agent-skills-101-tools-vs-mcp-vs-skills) and come back here for the hands-on setup.
---
## What Are MCP Servers in Claude Code?
MCP stands for Model Context Protocol. It is an open standard by Anthropic that defines how AI models connect to external tools, databases, and APIs. An MCP server is a process that exposes tools, resources, and prompts over this standardized protocol. Claude Code acts as an MCP client, connecting to one or more servers and calling their tools during your session.
With MCP servers connected, you can ask Claude Code to:
- Implement a feature from a Jira ticket and open the PR on GitHub, without leaving the terminal
- Query your production database to find users who hit a specific bug
- Check Sentry for errors after a deployment
- Run Playwright browser tests and take screenshots
- Pull Figma designs and convert them to code
Connect a server when you find yourself copy-pasting data from another tool into chat. Once connected, Claude reads and acts on that system directly.
---
## Claude Code MCP vs Claude Cowork
Anthropic now offers two agentic products: Claude Code for developers and Claude Cowork for knowledge workers. Both use MCP under the hood, but the experience is completely different.
**Claude Code** is a CLI tool. You add MCP servers with `claude mcp add`, configure them in JSON files, and control scope at the project, user, or organization level. You have full control over transport types, auth tokens, and environment variables. MCP in Claude Code is infrastructure you manage.
**Claude Cowork** is a desktop application for non-technical users. It handles tasks autonomously on your computer, working with local files and applications. Cowork has its own connector system with enterprise integrations like Google Drive, Gmail, DocuSign, and FactSet. You don't configure MCP servers manually. Cowork manages that layer for you.
The key differences:
- **Interface:** Claude Code runs in your terminal. Cowork runs as a desktop GUI.
- **MCP control:** Claude Code gives you full access to add, remove, configure, and debug MCP servers. Cowork abstracts this away behind managed connectors and plugins.
- **Target user:** Claude Code is for developers and engineers. Cowork is for ops, finance, marketing, and other knowledge workers.
- **Custom servers:** Claude Code lets you build and connect your own MCP servers. Cowork relies on Anthropic-vetted connectors.
- **Team sharing:** Claude Code shares MCP configs through `.mcp.json` committed to git. Cowork uses enterprise admin controls.
If you are writing code, shipping features, or building integrations, Claude Code MCP is what you want. If your team needs file organization, document prep, or research synthesis without touching a terminal, Cowork handles that.
For teams that need both, [Duet](/) gives you a shared workspace where developers and non-technical teammates collaborate with agents in the same place, with MCP integrations pre-configured.
---
## How to Add an MCP Server to Claude Code
There are two ways to add an MCP server: the CLI command and manual JSON configuration.
### Method 1: The claude mcp add command
The fastest way to connect a server. The syntax depends on the transport type.
**For remote HTTP servers (recommended for cloud services):**
```bash
# Basic syntax
claude mcp add --transport http
# Example: Connect to Notion
claude mcp add --transport http notion https://mcp.notion.com/mcp
# With authentication header
claude mcp add --transport http github https://api.githubcopilot.com/mcp/ \
--header "Authorization: Bearer YOUR_GITHUB_PAT"
```
**For local stdio servers (runs as a subprocess on your machine):**
```bash
# Basic syntax
claude mcp add [options] -- [args...]
# Example: Add Playwright for browser testing
claude mcp add --transport stdio playwright -- npx -y @playwright/mcp@latest
# Example: Add a database server with env vars
claude mcp add --transport stdio --env AIRTABLE_API_KEY=YOUR_KEY airtable \
-- npx -y airtable-mcp-server
```
> **Important:** All options (`--transport`, `--env`, `--scope`, `--header`) must come before the server name. The `--` (double dash) separates the server name from the command that gets passed to the MCP server.
### Method 2: JSON configuration
For more complex setups or team sharing, add servers via JSON:
```bash
# Add from JSON directly
claude mcp add-json weather-api '{"type":"http","url":"https://api.weather.com/mcp","headers":{"Authorization":"Bearer token"}}'
# Add a stdio server from JSON
claude mcp add-json local-db '{"type":"stdio","command":"/path/to/server","args":["--port","8080"],"env":{"DB_URL":"postgres://..."}}'
```
### Managing servers
```bash
# List all configured servers
claude mcp list
# Get details for a specific server
claude mcp get github
# Remove a server
claude mcp remove github
# Inside Claude Code, check server status
/mcp
```
If you have MCP servers already configured in Claude Desktop, you can import them:
```bash
claude mcp add-from-claude-desktop
```
This works on macOS and WSL. It reads your Claude Desktop config and lets you select which servers to import.
---
## MCP Configuration Scopes: Local, Project, and User
Where you store your MCP config determines who can access it and which projects it loads in. Claude Code supports three scopes.
**Local scope (default)** stores the config in `~/.claude.json` under your current project path. Only you can see it, only in this project. Good for personal dev servers or configs with credentials you do not want in version control.
```bash
# Local scope (default)
claude mcp add --transport http stripe https://mcp.stripe.com
# Explicitly specify local
claude mcp add --transport http stripe --scope local https://mcp.stripe.com
```
**Project scope** writes to `.mcp.json` at your project root. This file is designed to be committed to git, so every team member gets the same MCP servers automatically.
```bash
# Add a project-scoped server
claude mcp add --transport http paypal --scope project https://mcp.paypal.com/mcp
```
The resulting `.mcp.json`:
```json
{
"mcpServers": {
"paypal": {
"type": "http",
"url": "https://mcp.paypal.com/mcp"
}
}
}
```
**User scope** stores the config in `~/.claude.json` globally. The server loads in every project on your machine. Good for utility servers you use everywhere.
```bash
claude mcp add --transport http hubspot --scope user https://mcp.hubspot.com/anthropic
```
Precedence order when the same server exists in multiple scopes: Local > Project > User > Plugins > Claude.ai connectors. The highest-precedence definition wins. Fields are not merged across scopes.
The `.mcp.json` file supports environment variable expansion with `${VAR}` syntax. This lets your team share configs while keeping credentials in each developer's environment:
```json
{
"mcpServers": {
"api-server": {
"type": "http",
"url": "${API_BASE_URL:-https://api.example.com}/mcp",
"headers": {
"Authorization": "Bearer ${API_KEY}"
}
}
}
}
```
---
## Best MCP Servers for Claude Code (2026)
These are the servers that matter most for coding workflows. Each entry includes what it does, how to connect it, and the auth method.
### GitHub
PRs, issues, code search. Transport: HTTP. Auth: GitHub PAT.
```bash
claude mcp add --transport http github https://api.githubcopilot.com/mcp/ \
--header "Authorization: Bearer YOUR_GITHUB_PAT"
```
### Playwright
Browser automation, testing, screenshots. Transport: stdio. Auth: None.
```bash
claude mcp add --transport stdio playwright -- npx -y @playwright/mcp@latest
```
### Sentry
Error monitoring, stack traces, deployment tracking. Transport: HTTP. Auth: OAuth via `/mcp`.
```bash
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
```
### Notion
Documentation, databases, knowledge bases. Transport: HTTP. Auth: OAuth.
```bash
claude mcp add --transport http notion https://mcp.notion.com/mcp
```
### Supabase
Database queries, auth management, edge functions. Transport: stdio. Auth: Service key.
```bash
claude mcp add --transport stdio --env SUPABASE_KEY=YOUR_KEY supabase \
-- npx -y @supabase/mcp-server
```
### Linear
Issue tracking, project management, sprint planning. Transport: HTTP. Auth: API key.
```bash
claude mcp add --transport http linear https://mcp.linear.app/mcp
```
### Slack
Channel reads, message search, posting updates. Transport: HTTP. Auth: OAuth.
```bash
claude mcp add --transport http slack https://mcp.slack.com/mcp
```
### Figma
Design-to-code, component inspection, asset export. Transport: HTTP. Auth: OAuth.
```bash
claude mcp add --transport http figma https://mcp.figma.com/mcp
```
### Context7
Up-to-date library documentation. Transport: stdio. Auth: None.
```bash
claude mcp add --transport stdio context7 -- npx -y @context7/mcp-server
```
### PostgreSQL (via dbhub)
Direct database queries against your Postgres instance. Transport: stdio. Auth: Connection string.
```bash
claude mcp add --transport stdio db -- npx -y @bytebase/dbhub \
--dsn "postgresql://readonly:pass@host:5432/analytics"
```
### Jira / Atlassian
Issues, projects, sprint boards. Transport: HTTP. Auth: API token.
```bash
claude mcp add --transport http atlassian https://mcp.atlassian.com/mcp
```
Browse the full catalog of reviewed connectors in the [Anthropic Directory](https://claude.ai/directory).
---
## stdio vs Remote HTTP: Which Transport to Use
Claude Code supports two primary transport types for MCP servers.
**stdio (local)** spawns the server as a subprocess on your machine. Messages flow through stdin/stdout. Best for dev tools that need filesystem access, local databases, CLI wrappers, and tools with no remote endpoint. Downside: only works on your machine, not shareable across a team.
**HTTP (remote)** connects to a server running independently over HTTPS. Best for cloud services, team-shared tools, and SaaS integrations. Supports OAuth, automatic reconnection with exponential backoff, and Server-Sent Events for streaming.
> SSE transport is deprecated. Use HTTP where available.
Decision guide:
- Building something for just you? Use stdio.
- Connecting to a SaaS product? Use HTTP.
- Sharing with your team? Use HTTP with project-scoped `.mcp.json`.
- Running a custom script or CLI tool? Use stdio.
---
## Authentication and Security
MCP servers that connect to cloud services need credentials. Claude Code handles this in several ways.
**OAuth 2.0 (recommended for cloud services).** Many remote MCP servers use OAuth. Claude Code handles the flow automatically. Add the server, run `/mcp`, and follow the browser login prompt. Tokens are stored securely and refreshed automatically.
**Bearer tokens and API keys.** Pass static tokens via headers when adding the server:
```bash
claude mcp add --transport http github https://api.githubcopilot.com/mcp/ \
--header "Authorization: Bearer ghp_xxxxxxxxxxxx"
```
**Environment variables for stdio servers.** Pass sensitive values without hardcoding them:
```bash
claude mcp add --transport stdio --env DB_PASSWORD=secret db -- ./my-db-server
```
**Dynamic headers.** For custom auth schemes (Kerberos, internal SSO), use `headersHelper` in `.mcp.json` to run a script that generates auth headers at connection time.
Security best practices:
- Never commit API keys to git. Use env var expansion in `.mcp.json` instead.
- Use read-only credentials where possible.
- Restrict OAuth scopes to only what you need.
- Verify you trust each MCP server before connecting. Servers that fetch external content can expose you to prompt injection.
---
## How MCP Tools Work at Runtime
After you add an MCP server, here is what happens when you start a Claude Code session.
**Tool Search is enabled by default.** Claude Code does not load every MCP tool into context upfront. Instead, it defers them. Only tool names load at session start. When Claude needs a specific tool, it uses an internal ToolSearch function to find and load the relevant tool definition on demand. This keeps your context window lean, even if you have dozens of MCP servers connected.
You can check server status any time with `/mcp`. It shows connected servers, tool counts, and flags any servers that failed to connect.
If a server disconnects mid-session, Claude Code automatically reconnects HTTP servers with exponential backoff (up to 5 attempts). Stdio servers are local processes and are not reconnected automatically.
MCP servers can also push messages into your session via **Channels**. This lets Claude react to external events like CI results, monitoring alerts, or chat messages while you work.
---
## Troubleshooting Common MCP Issues
**Server not connecting.** Run `claude mcp list` to confirm the server is registered. Then run `/mcp` inside Claude Code to see the status. Check that the command or URL is correct. For stdio servers, verify the binary or npx package exists.
**Authentication failures.** For OAuth servers, clear auth with `/mcp` and re-authenticate. For header-based auth, verify the token has not expired. For env-var auth, make sure the variable is set in your shell before launching Claude Code.
**Timeout errors.** MCP servers have a default startup timeout. Set `MCP_TIMEOUT=10000` before launching Claude Code to increase it to 10 seconds. For per-tool execution timeouts, add a `timeout` field in your `.mcp.json` entry.
**"Could not find tool" errors.** If Tool Search is enabled (default), Claude searches for tools on demand. If you disabled it, all tools load upfront and may exceed context limits. Make sure the server is actually connected before expecting its tools.
**Transport mismatch.** If a server expects HTTP and you configured stdio (or vice versa), the connection silently fails. Check the server's docs for the correct transport type.
**Large output warnings.** MCP tool output that exceeds 10,000 tokens triggers a warning. Set `MAX_MCP_OUTPUT_TOKENS=50000` to raise the limit if you are querying large datasets.
---
## Frequently Asked Questions
**What is the difference between MCP in Claude Code and Claude Cowork?**
Claude Code gives you full CLI control over MCP servers: add, remove, configure, debug. Claude
Cowork abstracts MCP behind managed connectors and a desktop GUI. Code is for developers. Cowork
is for knowledge workers.
**How do I add an MCP server to Claude Code?**
Run `claude mcp add --transport http name url` for remote servers, or `claude mcp add
--transport stdio name -- command` for local servers. You can also edit `.mcp.json` directly or
use `claude mcp add-json` for complex configurations.
**What are the best MCP servers for Claude Code?**
For most dev workflows: GitHub, Playwright, Sentry, and your database via dbhub. For
design-to-code: Figma. For docs: Notion. For project management: Linear or Jira. Browse the full
catalog at claude.ai/directory.
**How do I share MCP config across my team?**
Use `--scope project` when adding servers. This writes to `.mcp.json` at your project root.
Commit that file to git, and every team member who clones the repo gets the same MCP servers.
For credentials, the `${VAR}` syntax lets each developer provide their own tokens via
environment variables.
**Can MCP servers work with Claude Code subagents?**
Yes. Subagents inherit MCP tools from the main session by default. You can restrict them with
`allowed-tools` in skill definitions if you want to limit which tools a subagent can access.
**How do I debug MCP connection issues?**
Run `claude mcp list` to verify registration. Run `/mcp` inside Claude Code to check status. For
HTTP servers, check auth tokens. For stdio servers, verify the command exists. Set `MCP_TIMEOUT`
for slow startups.
**What is the difference between stdio and HTTP transport?**
stdio spawns the server as a local subprocess. Messages flow through stdin/stdout. HTTP connects
to a remote server over HTTPS. Use stdio for local tools and scripts. Use HTTP for cloud
services and team-shared integrations.
**Do MCP servers work with Duet AI?**
Yes. Duet ships with MCP integrations pre-configured for teams. No manual setup required. Your
agents connect to Slack, GitHub, Notion, and more out of the box.
**Is MCP the same as Skills in Claude Code?**
No. MCP provides access to external tools and data. Skills encode how to use those tools in
multi-step workflows with quality checks and templates. They are complementary. Read our{' '}
Skills vs MCP guide for the full
breakdown.
**Can Claude Code connect to a custom MCP server I built?**
Yes. Build your server following the MCP specification, then add it with `claude mcp add`. You
can also use the `mcp-server-dev` plugin to scaffold a new server from within Claude Code by
running `/plugin install mcp-server-dev@claude-plugins-official`.
## Keep reading
- [Skills vs MCP: What's the Difference and When to Use Each](/guides/agent-skills-101-tools-vs-mcp-vs-skills). The conceptual foundation for understanding MCP's role alongside Tools and Skills.
- [Claude Code Skills: The Complete Guide](/guides/claude-code-skills-complete-guide). Skills and MCP are complementary. This guide covers how to build and share skills.
- [Claude Code for Teams](/guides/claude-code-for-teams). Team setup including shared MCP configuration, permissions, and workflows.
- [MCP Alternatives for Code Execution Agents](/blog/mcp-alternatives-code-execution-agents). When MCP is not the right fit, explore other approaches.
- [How to Run Claude Code in the Cloud](/blog/how-to-run-claude-code-in-the-cloud). Run Claude Code (and its MCP servers) on remote infrastructure.
---
Source: https://duet.so/guides/claude-code-memory
# Claude Code Memory: Complete Guide to Making Claude Remember Everything
*Set up Claude Code memory with CLAUDE.md files. Persistent instructions, project conventions, and team-shared context across sessions.*
By Duet Team. Published 2026-06-03. 21 min read.
## What is Claude Code Memory?
Claude Code Memory is the system that lets Claude Code store and recall information across sessions.
Without it, every time you start a new conversation, Claude has no context about you, your project, or your preferences. With it, Claude reads your saved instructions the moment a session begins.
At its core, Claude Code memory works through special markdown files called `CLAUDE.md`. These are plain text files that you place in specific locations in your project or home directory. When you start a Claude Code session, Claude automatically reads these files and treats their contents as instructions.
Think of it like leaving a note for a colleague before they start a shift. Except the colleague reads that note every single time, without fail.
There are two ways memory gets created:
**Manual Memory** is when you explicitly tell Claude to remember something. You write instructions in a `CLAUDE.md` file, or use the `#` shortcut during a conversation to save a note. You control exactly what gets saved.
**Auto Memory** is when Claude Code decides on its own that something is worth remembering. If you correct Claude's behavior during a session, say, "don't use semicolons in this project", Claude may automatically save that as a memory for future sessions. You can turn this on or off in settings.
Both types end up in the same place: `CLAUDE.md` files that Claude reads at session start. The difference is just who writes them.
## How Claude Code Memory Works
Claude Code memory isn't one big file. It's a layered system with three tiers, each serving a different scope. Understanding this hierarchy is key to using memory effectively.
### Global Memory
Global memory lives at `~/.claude/CLAUDE.md`, a file in your home directory's `.claude` folder. Anything you put here applies to every project you work on with Claude Code, across all repositories.
This is the place for personal preferences that don't change between projects:
- Your preferred coding style (tabs vs spaces, naming conventions)
- Your name and role, so Claude addresses you correctly
- Tools you always want Claude to use or avoid
- General rules like "always write tests" or "never use `any` in TypeScript"
Global memory is loaded first, before anything else. It's your baseline.
### Project Memory
Project memory lives in two possible locations within your repository: `CLAUDE.md` in your project root, or `.claude/CLAUDE.md` inside the `.claude` directory.
This is where project-specific context goes. Your tech stack, database conventions, folder structure, deployment process, key architectural decisions. Anything that a developer would need to know before contributing to this specific project.
Project memory is the most important tier for teams. You can commit these files to git, which means every developer on the team shares the same context. Claude behaves consistently across everyone's sessions.
### Session Memory
Session memory is the conversation itself, everything you and Claude discuss during a single session. This includes your messages, Claude's responses, tool outputs, file reads, and any corrections you make along the way.
Session memory is temporary. When you close the session, it's gone. Claude Code does use automatic summarization to handle long conversations, but once the session ends, nothing carries over unless it gets saved to a `CLAUDE.md` file (manually or through auto memory).
### How Do Tiers Stack?
When a session starts, Claude reads memory in order: global first, then project, then session context as you interact. If there's a conflict, say your global memory says "use tabs" but the project memory says "use spaces", the more specific tier wins. Project overrides global. Session overrides both.
This means you can set broad defaults globally and override them per project without editing your global file every time you switch repos.
## How to Set Up Claude Code Memory
Setting up memory takes under five minutes. Here's how to go from zero to a working memory system.
### Create your global memory file
Open your terminal and create the global `CLAUDE.md`:
```bash
mkdir -p ~/.claude && touch ~/.claude/CLAUDE.md
```
Open the file in any text editor and add your personal defaults. Start simple:
```markdown
# Global preferences
- I prefer TypeScript with strict mode
- Use functional components in React, not class components
- Always write unit tests for new functions
- Explain your reasoning before writing code
```
Save the file. Every Claude Code session you start from now on will read these instructions automatically.
### Create your project memory file
Navigate to your project's root directory and create a project-level `CLAUDE.md`:
```bash
touch CLAUDE.md
```
Add context specific to this project:
```markdown
# Project: my-saas-app
- Tech stack: Next.js 14, TypeScript, Prisma, Postgres
- Styling: Tailwind CSS, no custom CSS files
- Testing: Vitest for unit tests, Playwright for E2E
- API routes go in src/app/api/
- Database migrations: run npx prisma migrate dev
- Never modify the auth module without explicit approval
```
This file lives in your repo. If you commit it to git, your entire team benefits from the same context.
### Try the # shortcut
The fastest way to save a memory during a conversation is the `#` shortcut. While chatting with Claude Code, just type:
```
# always use pnpm instead of npm in this project
```
Claude Code saves this to your project's `CLAUDE.md` automatically. No need to open the file and edit it manually. This is useful when you catch Claude doing something wrong mid-session and want to prevent it from happening again.
### Enable auto memory
Auto memory lets Claude Code save context on its own when it learns something important during a session. To enable it, run:
```bash
claude config set --project autoMemory true
```
With auto memory on, if you correct Claude ("don't use semicolons" or "this project uses yarn, not npm"), Claude may save that correction automatically for future sessions.
That's it. Four steps and your Claude Code sessions now have persistent memory.
## Claude Code Auto Memory vs Manual Memory
Claude Code gives you two ways to build memory. Understanding when to use each one helps you build a cleaner, more useful memory system.
### Manual Memory
You decide what to save. Manual memory is anything you write yourself: editing `CLAUDE.md` files directly in your text editor, using the `#` shortcut during a session to save a quick note, and using the `/memory` command to view and add memories.
Manual memory gives you full control. You choose the wording, the structure, and what makes the cut. It's ideal for foundational instructions that you've thought through, your project architecture, coding standards, deployment workflows, or team conventions.
The downside is that it requires effort. You have to notice when Claude needs a correction, stop your workflow, and write it down.
### Auto Memory
Claude decides what to save. When enabled, Claude pays attention to corrections you make during a session and saves them automatically. For example, if you say "use single quotes, not double quotes" during a conversation, Claude recognizes that as a preference worth remembering. It saves a note to your `CLAUDE.md` file so it doesn't repeat the mistake next session.
Auto memory is great for catching things you wouldn't think to write down. The small preferences and one-off corrections that add up over time. It fills the gaps that manual memory misses.
The downside is less control. Auto memory might save something you didn't intend to keep, or phrase it in a way that's too specific or too vague. It's worth reviewing what auto memory saves periodically.
**Which should you use? Both.**
Start with manual memory for the big stuff, project context, tech stack, key rules. Then turn on auto memory to catch the smaller preferences that emerge naturally as you work. Check your `CLAUDE.md` files occasionally to clean up anything auto memory saved that doesn't belong.
Think of manual memory as writing the employee handbook. Auto memory is the sticky notes that accumulate on the desk.
## CLAUDE.md Examples to Steal
The hardest part of setting up Claude Code memory is knowing what to actually write. Here are three real-world `CLAUDE.md` examples for common project types. Copy whichever fits your stack and customize from there.
### Example 1: Next.js SaaS Project
```markdown
# Project Context
This is a Next.js 14 app with App Router, TypeScript, and Tailwind CSS.
Database is Postgres via Prisma ORM. Auth is handled by NextAuth.
# Code Conventions
- Use server components by default. Only add "use client" when needed.
- API routes go in src/app/api/[route]/route.ts
- All database queries go through Prisma. No raw SQL.
- Use Zod for request validation in API routes.
- Component files use PascalCase. Utility files use camelCase.
# Testing
- Vitest for unit tests. Test files live next to source files as \*.test.ts
- Playwright for E2E tests in the /e2e directory.
- Run tests with: pnpm test
# Things to Avoid
- Never modify the auth configuration without asking first.
- Don't install new dependencies without confirming.
- Don't use any. Define proper types.
```
### Example 2: Python Data Pipeline
```markdown
# Project Context
ETL pipeline built with Python 3.12, pandas, and SQLAlchemy.
Data flows from S3 -> transform -> Postgres warehouse.
# Code Conventions
- Follow PEP 8 strictly. Use Black for formatting.
- Type hints on all function signatures.
- Docstrings on all public functions (Google style).
- Use pathlib for file paths, not os.path.
# Environment
- Virtual env managed with Poetry. Run: poetry install
- Environment variables loaded from .env via python-dotenv.
- Never hardcode credentials. Always use env vars.
# Deployment
- Runs on Airflow. DAG definitions in /dags directory.
- Staging DB: warehouse-staging. Production DB: warehouse-prod.
- Never run against production without explicit approval.
```
### Example 3: Global Personal Preferences
```markdown
# About Me
I'm a full-stack developer. I prefer clear, readable code over clever code.
# Coding Style
- Use descriptive variable names. No single-letter variables except loop counters.
- Prefer early returns over deeply nested if statements.
- Keep functions under 30 lines. If it's longer, break it up.
- Write comments only when the why isn't obvious from the code.
# Communication
- Explain your approach briefly before writing code.
- If you're unsure about a requirement, ask before assuming.
- When suggesting changes, explain what problem they solve.
# Tools
- Use pnpm, not npm or yarn.
- Prefer Vitest over Jest for new projects.
- Use Biome for linting and formatting when available.
```
These examples work because they're specific, actionable, and short enough that Claude can read them without eating up too much of the context window. The most effective `CLAUDE.md` files stay under 500 lines. Anything longer and you're trading memory for context space.
## How to Manage Claude Code Memory
Once your Claude Code memory starts growing, especially with auto memory enabled, you'll need to manage it. Here's how to stay in control.
**Viewing your current memories.** The fastest way to see what Claude Code remembers is the `/memory` command. Type it during any session and Claude will show you the contents of your active `CLAUDE.md` files, both global and project-level. You can also just open the files directly: global memory at `~/.claude/CLAUDE.md`, project memory at `CLAUDE.md` or `.claude/CLAUDE.md` in your repo.
**Editing memories.** This is one of the best things about how Claude Code memory works: it's just a text file. There's no database, no hidden settings, no UI you need to navigate. Open the `CLAUDE.md` file, change whatever you want, save it. The next session picks up your changes immediately. You can also ask Claude to edit its own memory during a session. Say something like "update your memory to reflect that we've switched from Jest to Vitest" and Claude will modify the `CLAUDE.md` file for you.
**Resetting memory.** Sometimes you want to start fresh. To reset project memory, simply delete or empty the file:
```bash
echo "" > CLAUDE.md
```
To reset global memory:
```bash
echo "" > ~/.claude/CLAUDE.md
```
There's no undo, so if you think you might want some of the old content back, make a backup first:
```bash
cp ~/.claude/CLAUDE.md ~/.claude/CLAUDE.md.bak
```
**Keeping memory clean over time.** A good habit is to review your `CLAUDE.md` files every couple of weeks. Look for entries that are outdated, duplicated, or overly specific. A lean memory file performs better than a bloated one. Fewer instructions means Claude spends less of its context window on memory and more on your actual task.
## Where Claude Code Memory Falls Short
Claude Code memory is useful, but it has real limitations. Understanding these helps you work around them instead of being surprised mid-session.
### No Semantic Recall
Claude Code memory is file-based. Claude reads the entire `CLAUDE.md` at session start and holds it in its context window. It doesn't search through memories by meaning or relevance. If your `CLAUDE.md` file is 200 lines long, Claude loads all 200 lines every session, even if only 5 are relevant to what you're working on today. There's no "smart retrieval", it's all or nothing.
### No Cross-Project Memory
What Claude learns in one project stays in that project's `CLAUDE.md`. If you have the same convention across ten repos, say, "always use pnpm", you either put it in global memory (which applies to everything, even projects that use npm) or duplicate it across all ten project files.
### Context Window Trade-off
Every line of Claude Code memory takes up space in the context window. A large `CLAUDE.md` file means less room for actual conversation, code, and tool outputs during your session. This is the fundamental tension with file-based memory: the more you remember, the less working space you have.
### No Memory Between Team Members
`CLAUDE.md` files are committed to git, which is good for sharing project conventions. But there's no way for one developer's session learnings to benefit another developer automatically. If you discover a useful pattern and want the team to know, you have to manually add it to the shared `CLAUDE.md`.
### Inaccuracy in Auto Memory
When Claude Code auto memory saves something, it's making a judgment call about what's worth remembering. Sometimes it saves things that are too specific or misinterprets a one-time instruction as a permanent preference. Without regular cleanup, auto memory can clutter your `CLAUDE.md` with noise.
## DIY Workarounds for Claude Code Memory Limits
Before reaching for third-party tools, there are a few things you can do within the native system to stretch Claude Code memory further.
**Split your CLAUDE.md by concern.** Instead of one massive file, create focused memory files for different parts of your project. Put your main conventions in the root `CLAUDE.md` and use `.claude/CLAUDE.md` for more detailed, session-specific context. This doesn't reduce total memory usage, but it makes files easier to maintain.
**Use conditional context injection.** Write a hook (using Claude Code's hook system) that reads different context files based on what you're working on. If you're editing files in `/api`, inject the API conventions. If you're in `/frontend`, inject the component guidelines. This way, Claude only loads relevant context instead of everything at once.
**Build a memory rotation habit.** Set a recurring reminder to review and trim your `CLAUDE.md` files. Archive old entries into a separate file (like `CLAUDE-archive.md`) that isn't auto-loaded. This keeps your active memory lean while preserving historical context you can manually reference when needed.
**Use git to track memory changes.** Since `CLAUDE.md` is a regular file, git tracks every change. Run `git log CLAUDE.md` to see how your project memory has evolved. This is especially useful when auto memory adds something unexpected. You can use `git diff` to spot what changed and revert if needed.
## Claude Code Memory Best Practices
Getting Claude Code memory to work is easy. Getting it to work well takes a bit of thought. Here are the practices that separate a messy `CLAUDE.md` from one that actually makes Claude faster and more accurate.
### Be specific with prompts
"Write good code" tells Claude nothing. "Use early returns instead of nested if/else blocks" gives it a clear rule to follow. Every memory entry should be actionable. If Claude can't change its behavior based on the instruction, the instruction is too vague.
Structure your `CLAUDE.md` with headings. Use markdown headers to group related instructions. Put coding standards in one section, project architecture in another, and testing requirements in a third. This helps Claude find the relevant rule quickly instead of parsing a wall of text.
### Keep memory files under 500 lines
Claude reads your `CLAUDE.md` at the start of every session, and it counts against your context window. A 2,000-line file full of edge cases will eat into the space Claude needs for your actual code. Be concise. If a rule needs a paragraph of explanation, it might be too complex for memory.
### Write rules, not explanations
Your `CLAUDE.md` is an instruction manual, not a design document. Instead of explaining why your team chose Tailwind over styled-components, just write "use Tailwind CSS for all styling." Claude doesn't need the backstory.
### Use negative rules sparingly
"Never use `any`" or "don't use `var`" can be useful, but a file full of "don't do this" instructions is harder for Claude to follow than positive instructions. Prefer "use `const` and `let` for variable declarations" over "never use `var`."
### Commit project CLAUDE.md to git
This is a living document that your whole team benefits from. Track changes, review updates in PRs, and treat it like any other piece of project configuration. Your global `CLAUDE.md` stays on your machine since it contains personal preferences.
Review auto-generated memories weekly. Claude's auto memory feature saves things it thinks are important, but it doesn't always get it right. Set a reminder to open your `CLAUDE.md` files and clean out entries that are outdated, redundant, or just wrong.
## Troubleshooting Claude Code Memory Issues
Claude Code memory is straightforward, but there are a few common issues that trip people up. Here's how to diagnose and fix them.
**CLAUDE.md not found.** The filename is case-sensitive. It must be `CLAUDE.md` (all caps), not `claude.md` or `Claude.md`. Check with `ls -la CLAUDE.md` in your project root. Also make sure it's in the right location, either in the project root or inside a `.claude/` folder.
**Memories seem to be ignored.** If Claude isn't following your instructions, your `CLAUDE.md` might be too long. When the file exceeds a few hundred lines, Claude may deprioritize instructions that appear later in the file. Move your most important rules to the top, and trim anything redundant.
**Auto memory saves unwanted things.** Claude's auto memory can be overly eager. If it keeps saving things you don't want, you can disable it in settings or simply delete the unwanted entries from your `CLAUDE.md`. The `#` shortcut for manual memory gives you more control over what gets saved.
**Memory works in one project but not another.** Each project has its own `CLAUDE.md`. If you switch between projects and notice different behavior, check that the new project has its own `CLAUDE.md` file. Your global file at `~/.claude/CLAUDE.md` applies everywhere, but project-specific rules only apply in that project's directory.
**Memory seems to reset after updates.** Claude Code updates don't delete your `CLAUDE.md` files. They're just plain text files on your disk. But if you reinstall Claude Code from scratch or switch machines, your global `CLAUDE.md` won't follow unless you back it up. Consider storing it in a dotfiles repo or cloud sync folder.
## Making Claude Code Memory Work for You
Claude Code memory solves a real problem. Without it, every session starts from zero and you spend the first few minutes re-explaining your stack, your conventions, and your preferences. With a well-structured `CLAUDE.md`, Claude starts every session already knowing how you work.
The key takeaways: set up both a global and project-level `CLAUDE.md`, write specific rules instead of vague guidelines, use the `#` shortcut to save things mid-session, and review your memory files regularly to keep them clean. Start with 10-20 rules that cover your most common frustrations, then build from there.
That said, Claude Code memory has real limitations. It can't do semantic search, it doesn't share context across projects, and it eats into your context window. For teams and power users who need more, these gaps start to matter.
## Frequently Asked Questions
Claude Code memory works through plain text files called CLAUDE.md. Claude reads these files at the start of every session and follows the instructions inside them. There are three tiers: a global file for personal preferences, a project file for repository-specific rules, and session memory that only lasts for the current conversation. You can write instructions manually or let Claude save them automatically.
CLAUDE.md is a markdown file that stores instructions for Claude Code. It acts as persistent memory, telling Claude your coding preferences, project conventions, and workflow rules. The filename must be all caps (CLAUDE.md, not claude.md). You can place it in your home directory for global settings or in a project root for project-specific rules.
Not by default. Each Claude Code session starts fresh with no memory of previous conversations. But if you set up CLAUDE.md files, Claude reads them at session start, which effectively gives it memory across sessions. The key difference: Claude remembers your rules and preferences, but not the specific conversations or code changes from past sessions.
Auto memory is a feature that lets Claude automatically save important information to your CLAUDE.md files during a session. When Claude learns something significant, like your preferred test framework or naming convention, it writes it to CLAUDE.md so it remembers next time. You can enable it in Claude Code settings. It works best as a supplement to manual memory, not a replacement.
To reset project memory, open the CLAUDE.md file in your project directory and delete its contents or the file itself. For global memory, do the same with ~/.claude/CLAUDE.md. You can also run echo "" > CLAUDE.md to clear a file without deleting it. There's no reset button in the UI since the memory is just plain text files you control directly.
Global memory lives at ~/.claude/CLAUDE.md (in your home directory). Project memory lives at CLAUDE.md or .claude/CLAUDE.md in your project root. Session memory exists only in the current conversation and isn't saved to disk. You can have all three active at once, and they stack together with project rules taking priority over global ones.
Yes. Add your style rules to your project's CLAUDE.md file. For example: "use single quotes for strings," "prefer arrow functions over function declarations," or "always add JSDoc comments to exported functions." Claude will follow these rules in every session. This is one of the most common and effective uses of Claude Code memory.
Yes, by committing your project's CLAUDE.md to git. Every team member who clones the repo gets the same Claude Code instructions. This is a powerful way to standardize how Claude works across your entire team, no separate configuration tool needed. Keep personal preferences in your global CLAUDE.md (which stays local) and shared conventions in the project CLAUDE.md.
---
Source: https://duet.so/guides/claude-code-playbook-building-a-skill-first-workflow-that-actually-sticks
# The Claude Code Playbook: Skill-First Workflows
*Build skill-first workflows with Claude Code that stick. CLAUDE.md, commands, skills, and the Explore-Plan-Execute-Verify loop. No coding required.*
By Sawyer Middeleer. Published 2026-02-17, updated 2026-02-23. 15 min read.
We've been using Claude Code every day for months. Initially, it was chaos.
Claude would overwrite work it shouldn't touch. Ignore instructions we'd given five minutes earlier. Generate walls of output when a few sentences would've done the job. And the longer a session went, the more it drifted — confidently wrong about things that were true 20 minutes ago.
The model wasn't the problem. Our setup was.
So we built a system that works — and we're giving it away. Every person on the Duet team runs a version of this, and it just works. No coding experience required.
**TLDR;**
- A `CLAUDE.md` file that makes Claude behave consistently every single time
- Ready-made commands so you stop re-explaining yourself every session
- Skills that give Claude deep expertise in specific domains (marketing, writing, strategy)
- The Explore, Plan, Execute, Verify loop we run daily
- Context habits that prevent the slow drift that makes AI unreliable
---
## Before you start. This guide is good for you if…
You've tried Claude Code a few times. You think it's powerful but unpredictable. Some sessions are magic, others are a mess. You're tired of re-explaining the same things, or getting outputs that miss the mark.
This is the fix. And you don't need to be a developer to use it. If you haven't used Claude Code at all yet, start with [The Ultimate Beginner's Guide](/guides/claude-code-for-founders) first.
---
## Why Most People Struggle with Claude Code
Three gaps that explain 90% of bad sessions:
**1. Nothing is written down.**
Your brand voice, project context, preferences — they live in your head. Claude can't read minds. If your standards aren't in a file, Claude invents its own. Every time.
**2. Everyone starts from scratch.**
Every new session, you re-explain the same context. "Here's our brand voice. Here's our audience. Here's what we did last time." It's exhausting and the quality is inconsistent.
**3. Context degrades over time.**
Long sessions accumulate stale information. Claude starts referencing things from 30 minutes ago that aren't true anymore. Confidence stays high. Accuracy drops. You don't notice until you read the output closely.
The fix isn't better prompting. It's a system.
---
## CLAUDE.md: Your Project's Instruction Manual
`CLAUDE.md` is a file that Claude Code reads automatically at the start of every conversation. Think of it as a brief you'd write for a new freelancer — except this one actually gets read. Every. Single. Time.
Claude loads it from three places:
- `CLAUDE.md` in your project folder — shared context for your whole team
- `.claude/CLAUDE.md` — additional project details
- `~/.claude/CLAUDE.md` — your personal preferences (stays local to you)
### What goes in it
Keep it focused on five things:
**Project Overview:** What is this project? What are we working on?
> "Duet is a marketing platform for technical founders. Our audience is small teams under 10 people. Tone is direct, no-fluff, value-first."
**Key Context:** What does Claude need to know to do good work?
> "Our brand voice is conversational but authoritative. We never use corporate jargon. We target technical founders, not enterprise buyers."
**Preferences:** How should Claude approach tasks?
> "Keep outputs concise. Use bullet points over paragraphs. Always ask before making major changes to existing content."
**Reference Files:** Where should Claude look for more detail?
> "Brand voice guidelines are in `00_foundation/brand-voice/`. Check `raw-context/` for customer research and call notes."
**Do-Not List:** What should Claude avoid?
> "Never use buzzwords like 'synergy' or 'leverage.' Never publish content without review. Never change the brand voice doc without asking."
### Keep it short
This matters more than people think. `CLAUDE.md` loads into every conversation. The bigger it gets, the more space it takes up before you've even asked your first question. Aim for under 15KB. If it's growing past that, break things into separate files in `.claude/rules/` — they'll load automatically but only when relevant.
### Add a Definition of Done
This one addition will save you more frustration than everything else in this section combined:
```
## Definition of Done
- Output matches our brand voice
- Content is reviewed before publishing
- Sources are cited where applicable
- Formatting follows our style guide
- No placeholder text left in final output
```
Without this, Claude declares work "complete" prematurely. With it, Claude has a concrete checklist to hit. Simple as that.
---
## Commands: One-Click Workflows
Every time you type "write me a LinkedIn post about our new feature," you get slightly different results. The wording varies, the context changes, and Claude interprets it differently each time.
Commands fix this.
Commands are simple text files in `.claude/commands/` that become slash commands. The file name becomes the command name. The file content is the prompt. Everyone on your team gets identical, repeatable behavior.
```
.claude/commands/
blog-outline.md
linkedin-post.md
email-draft.md
competitor-brief.md
weekly-report.md
content-review.md
```
### Commands you should create on day one
| **Command** | **What it does** | **When to use** |
| ------------------- | ------------------------------------------------------------------ | ------------------------------------------------- |
| `/blog-outline` | Creates a structured blog outline with key points and CTA | Starting any new article |
| `/linkedin-post` | Drafts a LinkedIn post in your brand voice with a hook and CTA | Daily or weekly content creation |
| `/email-draft` | Writes an email sequence or one-off email following your templates | Outreach, nurture sequences, announcements |
| `/competitor-brief` | Researches a competitor and produces a structured comparison | Before writing comparison pages or sales material |
| `/weekly-report` | Summarizes this week's activity, metrics, and next steps | Monday planning or Friday wrap-up |
| `/content-review` | Reviews any content for brand voice, clarity, and effectiveness | Before publishing anything |
These are starting points. Create commands for anything you do repeatedly.
### Commands vs Skills: what's the difference?
This trips people up, so here's the simple version:
**Commands** are buttons you press. You type `/linkedin-post` and it runs. Explicit. Intentional. You decide when to use them.
**Skills** are expertise that activates automatically. Claude reads the skill description at startup. When your conversation matches a skill's domain — say, you ask about email sequences — the full skill instructions load automatically. You don't have to remember to trigger them.
Commands live in `.claude/commands/` (single files). Skills live in `.claude/skills/` (folders with supporting reference material).
**Use commands for repeatable workflows. Use skills for domain expertise.**
For example, you might have a `/linkedin-post` command that kicks off the writing process, while a `social-content` skill ensures Claude always knows best practices for LinkedIn formatting, hooks, and engagement — without you having to explain it.
---
## Skills: Giving Claude Deep Expertise
Skills are the most powerful — and most underused — feature in Claude Code. They turn Claude from a general-purpose assistant into a domain expert. For the full technical breakdown of how skills compare to tools and MCP, see [Agent Skills 101](/guides/agent-skills-101-tools-vs-mcp-vs-skills).
A skill is a folder containing:
- **`SKILL.md`** — the core instruction file with frameworks, best practices, and decision logic
- **Supporting files** — templates, examples, reference material
When Claude detects that your conversation matches a skill's domain, it automatically loads the full instructions. No prompting needed.
### Why skills matter
Without skills, every time you ask Claude to write marketing copy, you have to re-explain your frameworks, your audience, your voice. With skills, all of that is pre-loaded. Claude writes like someone who's read your entire marketing playbook — because it has.
### Example: how skills work in practice
Say you have these skills installed:
- `copywriting` — your copy frameworks, persuasion patterns, CTA formulas
- `brand-voice` — tone, vocabulary, dos and don'ts
- `email-sequence` — drip campaign best practices, subject line templates
When you say "write a welcome email sequence for new trial users," Claude automatically loads the email-sequence skill, cross-references your brand voice, and applies your copy frameworks. You get a polished output on the first try — not the third.
### Building your own skills
You don't need to be technical. A skill is just a markdown file with clear instructions:
```
# Skill: Blog Writing
## When to activate
When the user asks to write, outline, or edit a blog post.
## Instructions
- Always start with a hook that addresses a specific pain point
- Use short paragraphs (2-3 sentences max)
- Include a clear CTA at the end
- Reference our customer research in raw-context/ for real examples
- Follow our brand voice: conversational, direct, no jargon
## Templates
[Include your blog post template here]
```
Drop this in `.claude/skills/blog-writing/SKILL.md` and Claude picks it up automatically. For a deeper look at building a shared skill library that works across Claude.ai, the API, and the Agent SDK, see [Beyond Claude Code: Building a Shared Skill Library](/guides/beyond-claude-code-building-a-shared-skill-library).
---
## A Simple Workflow That Keeps Things on Track
Explore, Plan, Execute, Verify. This is what makes Claude Code predictable instead of chaotic.
### Explore first
Before Claude produces anything, make sure it understands the context.
This prevents the most common failure mode: Claude generating content that ignores your existing work, your audience, or constraints you mentioned two messages ago.
Point Claude to the relevant files. Have it read your brand guidelines, check your previous content, look at your notes. Never let Claude create from a blank slate when context exists.
### Plan before you execute
For anything beyond a quick one-liner, ask Claude to outline its approach first. This is the single biggest quality lever.
The most expensive mistake: skipping the plan on a "simple" task. Claude will happily generate 2,000 words of content that misses the point entirely. A 30-second plan prevents a 30-minute rewrite.
A good plan includes: what Claude will create, the structure it'll follow, which reference files it'll use, and what the output will look like.
### Execute in focused chunks
Once the plan looks right:
- One task at a time — don't ask Claude to write a blog post, three emails, and a landing page in one message
- Review as you go — catch drift early before it compounds
- Keep the scope tight — if Claude starts expanding beyond what you asked, pull it back
### Verify before you use it
Every output should pass your Definition of Done before you consider it finished. Does it match your brand voice? Is it the right length? Does it actually say something useful?
Build this into your `CLAUDE.md` so Claude checks itself — not because you remembered to ask.
---
## Connecting External Tools with MCP
MCP (Model Context Protocol) lets Claude Code talk to external tools you already use — Google Sheets, Notion, your CRM, email platforms. Instead of copying and pasting data between tools, Claude can read from and write to them directly. For setup instructions, see the [MCP Tools section in the Beginner's Guide](/guides/claude-code-for-founders#6-mcp-tools).
### Why this matters for GTM teams
Imagine telling Claude: "Pull our latest campaign data from the Google Sheet, cross-reference it with leads in our CRM, and draft a performance summary." With MCP, Claude can actually do this — no manual data wrangling. See [How to Run Your Entire Business with Claude Code](/guides/claude-code-for-founders) for real examples of this in action.
### Common MCP connections for non-engineering teams
| **Tool** | **What Claude can do** |
| ------------------------- | ----------------------------------------------------------- |
| Google Sheets | Read campaign data, update tracking sheets, create reports |
| Notion | Read meeting notes, update content calendars, pull research |
| CRM (Attio, HubSpot) | Look up contacts, enrich lead data, update records |
| Email (Instantly, Resend) | Pull campaign analytics, manage lead lists |
| LinkedIn | Research prospects, draft posts, check engagement |
### Start small
Don't connect everything at once. Each connection takes up space in Claude's memory. The rules:
- **Start with 1-2 tools** you use every day
- **Read-only first** — let Claude pull data before you let it write data
- **Test it** — make sure Claude returns the right information before building workflows around it
- **Document it** in your `CLAUDE.md` so your team knows what's available
---
## Context Hygiene: Keeping Claude Sharp
Every feature in this guide — `CLAUDE.md`, commands, skills, MCP — exists partly to manage one reality: Claude's memory fills up. And when it fills up, things go sideways quietly.
### /clear between tasks
If you're starting something unrelated to what Claude was just working on, type `/clear` first. Always.
The cost of re-establishing context is lower than the cost of Claude referencing stale information from a previous task. Every time.
### /compact when continuing
If you want to keep the current conversation going but Claude seems to be slowing down or losing track:
```
/compact Keep the content plan and brand voice notes. Drop the research.
```
But compaction is lossy — you can't fully control what gets kept. When in doubt, `/clear` and start fresh.
### The daily habits
- `/clear` between unrelated tasks
- Start new sessions for new projects
- Keep `CLAUDE.md` concise — every extra line costs space every session
- If Claude starts giving off-base responses, the context is stale. Clear it.
---
## Mistakes We've Made So You Don't Have To
| **Mistake** | **What happens** | **Fix** |
| ------------------------------- | --------------------------------------------------------- | --------------------------------------------------------- |
| No `CLAUDE.md` | Claude reinvents your standards every session | Create a minimal one today |
| Huge `CLAUDE.md` | Uses up Claude's memory before you even start | Keep under 15KB, use `.claude/rules/` for the rest |
| No skills installed | Claude gives generic outputs instead of expert-level work | Add skills for your core workflows (copy, email, content) |
| Skipping the plan | 2,000 words of content that misses the point | Always plan non-trivial work |
| Connecting too many tools | Claude's memory shrinks, quality drops | Start with 1-2 MCP connections |
| Never clearing context | Drift, stale references, off-brand outputs | `/clear` between tasks |
| Doing everything in one session | Claude loses track, outputs degrade | One task per session, use commands for consistency |
---
## Get the Starter Pack
We packaged everything from this guide into files you can drop into your project today:
- **`CLAUDE.md` template** — ready to customize with your brand and context
- **6 starter commands** — `/blog-outline`, `/linkedin-post`, `/email-draft`, `/competitor-brief`, `/weekly-report`, `/content-review`
- **Example skills** — copywriting, brand voice, and email sequence skills you can adapt
- **Context hygiene cheat sheet** — one-page reference for your team
**→** [**Download the Starter Pack**](https://github.com/anianroid/claude-code-starter-pack)
Drop your email and you'll get instant access to the full pack.
---
## Frequently Asked Questions
**What is CLAUDE.md and why does it matter?**
It's a file Claude Code reads automatically at the start of every session. Your project context,
brand guidelines, preferences — all in one place. Without it, Claude starts every session with
zero memory of how you work.
**Do I need coding experience to use this?**
No. `CLAUDE.md` is a plain text file. Commands are plain text files. Skills are plain text files
in folders. If you can write a Google Doc, you can set this up.
**What are skills and how do I use them?**
Skills are pre-written instructions that give Claude expertise in specific domains. Install them
in `.claude/skills/` and Claude automatically uses them when relevant. Think of them as hiring a
specialist instead of a generalist.
**Should I use commands or skills?**
Both, for different things. Commands for workflows you trigger on purpose (`/linkedin-post`,
`/email-draft`). Skills for expertise Claude should apply automatically (brand voice,
copywriting best practices). Start with commands. Add skills once you see patterns.
**How do I connect Claude to my other tools?**
Through MCP (Model Context Protocol). You configure connections in a `.mcp.json` file. Start
with one tool — usually Google Sheets or Notion — and expand from there. Ask your team or check
the Claude Code docs for setup steps.
**When should I use /clear vs /compact?**
`/clear` between unrelated tasks — it's a full reset (but keeps your `CLAUDE.md`). `/compact`
when you want to keep working on the same thing but need more room. Default to `/clear` when
possible — compaction is lossy.
**Can my whole team use the same setup?**
Yes. Everything in `.claude/commands/` and `.claude/skills/` can be shared. Commit it to your
project and everyone gets identical behavior. Personal preferences go in `~/.claude/` and stay
local.
---
Source: https://duet.so/guides/claude-code-skills-complete-guide
# Claude Code Skills: The Complete Guide (2026)
*Everything you need to know about Claude Code Skills — what they are, how SKILL.md works, when to use Skills vs MCP vs Subagents, how to build your first skill, and how to share them across a team.*
By Duet Team. Published 2026-05-02, updated 2026-05-08. 32 min read.
Six months ago, "extending Claude" meant either writing custom MCP servers or stuffing everything into a 5,000-line `CLAUDE.md` file. Then Anthropic shipped **Claude Code Skills** in October 2025, open-sourced the format that December, and within weeks OpenAI had adopted the same `SKILL.md` spec for Codex and ChatGPT. Suddenly there was a portable, model-invoked way to teach any coding agent how _your_ team actually works.
Skills have quietly become the most important primitive in Claude Code. They're the difference between an assistant that needs hand-holding through every workflow and one that knows your repo conventions, your review checklist, your deployment dance, and a hundred other things you'd otherwise have to repeat in every prompt. Even better: they're cheap. A skill costs about 100 tokens of context until Claude decides it's needed, meaning you can have fifty skills installed and pay almost nothing for the ones you aren't using right now.
But the ecosystem is moving fast, and there's confusion about what skills actually _are_, how they differ from MCP servers and subagents, what goes in the `SKILL.md` file, and how teams should organize them. **This guide is the canonical answer.**
We'll cover what a Claude Code skill is, how it compares to MCP and subagents (with a real decision matrix), the `SKILL.md` format down to the YAML frontmatter, a concrete 5-minute build of your first skill, the best practices that separate skills people actually invoke from skills that gather dust, how to share skills across a team so they compound instead of fragment, and where to find and install skills from the community.
---
## What is a Claude Code Skill?
A Claude Code Skill is a folder of instructions, scripts, and resources that Claude loads on demand to perform a specialized task in a repeatable way. Each skill lives in a directory containing a single `SKILL.md` file with YAML frontmatter (a name and description) and markdown instructions Claude follows when the skill is activated. Optional helper scripts, reference files, and templates can sit alongside it.
In one sentence, a skill is procedural knowledge — a reusable "how we do XYZ here" — packaged in a format Claude can discover and load itself.
### How a Claude Code Skill works in three steps
1. **Discovery.** When a Claude Code session starts, Claude scans the name and description from each installed skill's YAML frontmatter. This costs roughly 100 tokens per skill, regardless of how large the skill itself is.
2. **Activation.** When your prompt matches a skill's purpose, Claude loads the full `SKILL.md` body (typically under 5,000 tokens) into context. You don't have to invoke it manually — skills are _model-invoked_ by default.
3. **Execution.** Claude follows the instructions in the skill, calls any bundled scripts, and references supporting files only if the task actually needs them. This is called **progressive disclosure**, and it's what lets you install dozens of skills without bloating context.
### Skills are model-invoked, not user-invoked
This is the most important thing to understand about Claude Code Skills:
- **Slash commands** are _user-invoked._ You type `/deploy` and Claude runs it.
- **Skills** are _model-invoked._ Claude reads your prompt, decides a skill is relevant, and loads it on its own.
That's why the description field in YAML frontmatter matters so much. It's not documentation — it's the trigger. Claude is reading your description on every turn and asking, _"Does the user's request match this?"_ A vague description means a skill that never fires. A precise one means the skill activates exactly when it should.
### What can a Claude Code Skill do?
Almost anything you'd otherwise repeat in a system prompt or paste into chat:
- **Workflows:** "How we open a PR," "How we run database migrations," "How we write a postmortem."
- **Brand and style:** Voice guidelines, tone rules, formatting conventions.
- **Domain knowledge:** Industry-specific procedures, compliance requirements, internal taxonomies.
- **Tool wrappers:** "When the user asks about images, run this script and pass the result back."
- **Templates:** Boilerplate code, document scaffolds, standard checklists.
A skill can also bundle scripts (Python, Bash, Node, whatever runtime is available in the environment), reference files Claude should read on demand, and even other skills it composes with.
### Claude Code Skills are cross-platform
Anthropic released the Agent Skills specification as an open standard in December 2025. The same `SKILL.md` format now works across:
- **Claude Code** (terminal, desktop, web, IDE extensions)
- **Claude.ai** (the chat interface)
- **The Anthropic API**
- **OpenAI Codex CLI and ChatGPT** (adopted the format late 2025)
- **Gemini CLI, Cursor, and other compatible agents**
Build a skill once, run it anywhere your team uses an agent. This portability is part of why skills have moved from "neat feature" to "default way to extend an agent" so fast.
### Claude Code Skills vs CLAUDE.md vs prompts
People mix these three up all the time:
| | CLAUDE.md | Skills | Prompts |
| ---------- | ----------------------------- | -------------------------------------- | -------------------- |
| Loading | Always loaded every session | On demand (model-invoked) | Re-entered each time |
| Token cost | Full file size, every session | ~100 tokens idle, ~5K active | Paid per message |
| Best for | Global project conventions | Repeatable, context-specific workflows | One-off instructions |
| Scope | Project or user-wide | A specific task or workflow | Single conversation |
`CLAUDE.md` is _always loaded._ A skill is _loaded when needed._ That distinction is why a 50-skill library doesn't slow Claude down, but a 5,000-line `CLAUDE.md` does.
### Why Claude Code Skills are suddenly everywhere
Three things converged in late 2025:
1. **Progressive disclosure made them cheap.** Before skills, extending Claude meant inflating context permanently. Skills load on demand.
2. **The spec went open.** When OpenAI adopted the same format, skills stopped being a Claude feature and became an industry standard.
3. **Teams realized skills compound.** One developer's skill becomes the team's skill. The team's skill becomes the org's skill.
---
## Claude Code Skills vs MCP vs Subagents
Short answer: use Skills for _how_ to do something, MCP for _access_ to external systems, and Subagents for _delegating_ work to a specialist with its own context. Most production setups use all three. The trick is knowing which mechanism fits which problem — picking wrong inflates context cost, slows your sessions, and creates maintenance debt.
### Skills vs MCP vs Subagents comparison
| | Skills | MCP Servers | Subagents |
| ------------------ | -------------------------------------- | --------------------------------------- | ---------------------------------------------- |
| **What it does** | Teaches Claude how to perform a task | Connects Claude to external systems | Runs specialized work with its own context |
| **Context cost** | ~100 tokens idle, ~5K when active | ~10K+ per server (always loaded) | Own context window, separate from main session |
| **Best for** | Procedural knowledge, team conventions | APIs, databases, browsers, file systems | Async work, long research, parallel tasks |
| **Example** | PR review checklist | GitHub MCP, Postgres, Slack | Code-reviewer agent on Sonnet |
| **Who invokes it** | Claude (model-invoked) | Claude (on demand with Tool Search) | You or Claude (delegation) |
### When to use a Claude Code Skill
Pick a skill when Claude needs **procedural knowledge** — a way of doing something — that should activate based on context.
Good fits:
- "How we write commit messages"
- "Our PR review checklist"
- "How to format customer-facing emails in our brand voice"
- "Steps for running a database migration safely"
- "How to convert a PDF to clean markdown" (with a bundled script)
Skills shine when the same workflow repeats across many sessions and you don't want to re-explain it each time.
### When to use an MCP server
Pick MCP when Claude needs **access to a system it can't reach on its own** — APIs, databases, third-party tools, your file system over SSH, a browser.
Good fits:
- Read GitHub PRs and post comments
- Query a Postgres database
- Send Slack messages
- Control a headless browser
- Read from Google Drive or Notion
The catch: **MCP is expensive in context.** A typical 5-server setup with 58 tools eats roughly 55,000 tokens before you've sent a single prompt. Anthropic's Tool Search feature cuts this by ~85% by loading tool definitions on demand, but it's still the heaviest of the three primitives. Add MCP servers deliberately, not casually.
### When to use a Subagent
Pick a subagent when you need a **specialist with isolation** — its own context window, its own tools, sometimes a different model.
Good fits:
- A code-reviewer subagent that runs on Sonnet, has read-only file access, and never modifies code
- A research subagent on Haiku that scrapes docs and returns a summary without polluting the main context
- A long-running build subagent that can execute commands but can't edit files
- A security-review subagent in an isolated git worktree
Subagents matter when the _work_ should happen out of band — long research, parallel exploration, anything that would otherwise crowd out your main conversation.
### The decision tree
When you're not sure which one to reach for, walk this in order:
1. **Does Claude need access to an external system?** → MCP server.
2. **Does Claude need to do work independently, with its own context or model?** → Subagent.
3. **Does Claude need to know _how_ to do something repeatably?** → Skill.
4. **All of the above?** → Compose them. A subagent can call a skill that uses MCP. That's the most powerful pattern in Claude Code.
### Example: composing all three
Say you want Claude to review pull requests against your team's standards.
- **MCP server:** GitHub MCP — gives Claude access to PR diffs, comments, file content.
- **Skill:** `code-review-checklist` — the team's review conventions (security, naming, test coverage, PR description format).
- **Subagent:** `pr-reviewer` — runs on Sonnet, has read-only tools, isolated context. It calls the GitHub MCP to fetch the PR, loads the `code-review-checklist` skill for the methodology, posts comments via MCP, and returns a summary to the main session.
Three primitives, one specialist. None of them duplicate each other.
### Plugins: the wrapper around all three
Plugins are the distribution format. A plugin can bundle skills, subagents, MCP server configs, hooks, and slash commands into one installable package. If you're sharing capabilities across a team or open-sourcing them to the community, plugins are how you ship.
### What this means in practice
Most production Claude Code setups end up with:
- **5–10 skills** tailored to the team's workflow
- **3–5 MCP servers** for primary external systems (GitHub being almost universal)
- **2–4 subagents** for delegation patterns (review, research, async work)
If you've got more skills than MCP servers, you're probably doing it right. If you've got more MCP servers than skills, you're paying a context tax for capabilities you could express more cheaply.
---
## The SKILL.md Format
_YAML frontmatter and progressive disclosure explained_
**A `SKILL.md` file has two parts: YAML frontmatter between `---` markers that tells Claude _when_ to use the skill, and markdown instructions that tell Claude _how_.** That's the entire spec.
Everything else — scripts, references, templates — is optional and lives in the same folder.
### The minimum viable SKILL.md
```markdown
---
name: my-skill
description: A clear description of what this skill does and when to use it.
---
# My Skill
Instructions Claude follows when this skill is active.
```
Drop that file in `~/.claude/skills/my-skill/SKILL.md` and Claude Code will pick it up on next launch.
### YAML frontmatter fields
The frontmatter sits between `---` markers at the top of the file.
| Field | Required? | What it does |
| -------------------------- | -------------------- | -------------------------------------------------------------------------- |
| `name` | Recommended | Unique identifier. Shows up in skill lists and plugin manifests. |
| `description` | Strongly recommended | The trigger signal. Claude reads this to decide whether to load the skill. |
| `disable-model-invocation` | Optional | Set `true` to require explicit invocation. Default: `false`. |
| `allowed-tools` | Optional | Restricts which tools the skill can use while active. |
Example with all fields:
```markdown
---
name: api-error-handler
description: Use when reviewing or writing API endpoints that need consistent error handling. Covers status codes, error envelope format, and retry semantics for our internal services.
disable-model-invocation: false
allowed-tools: Read Grep Edit
---
```
### How Claude decides to load a skill
When a session starts, Claude scans every installed skill's frontmatter — name + description — costing roughly **100 tokens per skill.** That's the entire idle footprint.
The skill body, scripts, and any reference files don't load until Claude decides the skill is relevant.
Claude makes that decision by matching your prompt against each skill's description. So the description has two jobs:
1. **Tell Claude what the skill does.**
2. **Tell Claude when to use it.**
A description like `"Helper for emails"` will rarely fire. A description like `"Use when drafting customer-facing email replies. Applies our brand voice (warm, direct, no jargon) and our standard sign-off format."` will fire exactly when it should.
**Rule of thumb:** if you can't read your description and immediately know when to invoke the skill, neither can Claude.
### Progressive disclosure: the cost model
Progressive disclosure is the layered loading system that makes skills cheap:
| Tier | What loads | Token cost |
| -------------- | ----------------------------------- | ------------------------ |
| **Discovery** | `name` + `description` from YAML | ~100 tokens/skill |
| **Activation** | Full `SKILL.md` body | ~1K–5K tokens |
| **Execution** | Scripts, reference files, templates | Only what the task needs |
This is why you can have 50 skills installed and barely notice the overhead. Compare that to MCP, where every connected server pays its full token cost on every session whether you use it or not.
### Skill folder structure
A real-world skill folder usually looks like this:
```
~/.claude/skills/document-reader/
├── SKILL.md # Main instructions (under 500 lines)
├── examples.md # Usage examples Claude reads on demand
├── reference/
│ └── pdf-quirks.md # Edge cases, loaded only when relevant
└── scripts/
└── convert.py # Helper script the skill calls
```
In the `SKILL.md` body, you reference the supporting files by relative path. Claude only reads them when the workflow needs them — which is the whole point.
### SKILL.md body structure
There's no enforced template, but the skills that work best follow a predictable shape:
```markdown
---
name: skill-name
description: Specific trigger description
---
# Skill Name
One-paragraph summary of what this skill does and when it applies.
## When to use this skill
- Bullet list of trigger scenarios
## When NOT to use this skill
- Counter-cases that look similar but should use a different approach
## Instructions
Step-by-step procedure Claude should follow.
## Examples
Concrete before/after or input/output examples.
## References
- See `reference/edge-cases.md` for unusual situations
- See `scripts/helper.py` for the conversion utility
```
### The 500-line rule
Anthropic's own guidance: **keep the `SKILL.md` body under 500 lines.** If you're approaching that limit, split content into reference files in the same folder and link to them from the body. The body is the always-loaded-when-active layer; reference files are the on-demand layer.
---
## How to Build Your First Claude Code Skill in 5 Minutes
**The fastest way to learn Claude Code Skills is to build one.** This walkthrough takes about five minutes and gives you a working, model-invoked skill you can extend immediately. We'll build a `commit-message` skill that generates conventional commit messages from a diff.
### Step 1: Create the skill folder
Skills live in one of two places:
- **User-level (available everywhere):** `~/.claude/skills/`
- **Project-level (committed to a repo):** `.claude/skills/` inside the repo
For this walkthrough, we'll go user-level so it's available across every project.
```bash
mkdir -p ~/.claude/skills/commit-message
```
### Step 2: Create the SKILL.md file
```bash
cd ~/.claude/skills/commit-message
touch SKILL.md
```
Open `SKILL.md` in your editor and paste this:
```markdown
---
name: commit-message
description: Use when the user asks for a commit message, asks to commit changes, or wants to summarize a diff. Generates Conventional Commits format (type(scope): subject) with an optional body explaining the why, not the what.
allowed-tools: Bash Read
---
# Commit Message Generator
Generate a Conventional Commits-formatted commit message from the current staged changes.
## When to use this skill
- User says "write a commit message" or "commit this"
- User asks you to summarize a diff
- User wants help drafting a PR title (use the same format)
## When NOT to use this skill
- User wants a free-form changelog or release notes (different format)
- User explicitly asks for a non-Conventional-Commits style
## Instructions
1. Run `git diff --staged` to see the staged changes.
2. If nothing is staged, run `git diff` and warn the user the changes aren't staged yet.
3. Identify the primary change type: `feat`, `fix`, `refactor`, `docs`, `test`, `chore`.
4. Pick a scope from the changed files (e.g. the top-level package or feature folder). Omit if global.
5. Write the subject line: `type(scope): imperative verb + what changed`. Max 72 chars.
6. If the change is non-trivial, add a body after a blank line explaining _why_, not _what_.
7. Output ONLY the commit message — no preamble, no markdown fences.
## Examples
Input: a diff that adds rate limiting to the login endpoint.
Output:
feat(auth): add rate limiting to login endpoint
Brute-force attempts on /login were going unthrottled. Apply the same
sliding-window limiter we use on /signup (5 req/min per IP).
## Notes
- Subject line: imperative mood ("add" not "added"), no period.
- Body: wrap at 72 characters, blank line between paragraphs.
```
Save the file.
### Step 3: Test that it loads
Open a Claude Code session in any repo. You should see `commit-message` listed in the startup banner or via the skills list command.
### Step 4: Trigger it
Stage a change in a real repo:
```bash
git add some-file.js
```
Then in Claude Code, just say: _"Write a commit message for this."_
Claude will:
1. Match your prompt against the skill's description.
2. Load the skill body (~5K tokens).
3. Run `git diff --staged`, follow the instructions, and return a Conventional Commits-formatted message.
You didn't type a slash command. You didn't remind Claude of the format. **The skill activated itself.**
### Step 5: Iterate
**Tighten the trigger.** If the skill is firing on prompts you didn't intend, make the description more specific.
**Add a reference file.** If your team has a longer style guide, drop it in `~/.claude/skills/commit-message/reference/style-guide.md` and reference it from the body.
**Add a script.** If the logic gets complex, write a helper in `~/.claude/skills/commit-message/scripts/` and have the skill call it.
**Restrict tools.** This skill only needs `Bash` and `Read`. Setting `allowed-tools: Bash Read` tells Claude not to write files from this skill — a small but useful safety boundary.
### Step 6: Use the skill-creator skill
Anthropic ships an official `skill-creator` skill that scaffolds new skills for you. Once you've built one by hand, install `skill-creator` and let Claude handle the boilerplate next time:
> _"Use skill-creator to make me a skill that drafts release notes from merged PRs."_
The meta-trick of skills is that _they compose with each other._ A skill can recommend another skill. A subagent can call a skill. Once you internalize that, the question stops being "how do I extend Claude" and starts being "what's the smallest reusable unit that does this job."
---
## Claude Code Skills Best Practices
**The difference between a skill people actually use and a skill that gathers dust comes down to three things: a name that describes what it does, a scope narrow enough to fire reliably, and a description precise enough to trigger on the right prompts.**
### Naming: be specific, be searchable
The skill's `name` field is mostly for humans. Optimize it for two things:
- **Discoverability.** A teammate scanning a list of installed skills should know what each does without opening it.
- **Uniqueness.** Names should be globally distinguishable so you can install community skills without collision.
**Strong names:** `pr-review-checklist`, `migration-runner`, `customer-email-drafter`, `incident-postmortem`.
**Weak names:** `helper`, `reviewer` (which kind?), `email`, `utils`.
Use lowercase with hyphens. Avoid abbreviations unless they're universal in your domain.
### Scope: one skill, one job
The single biggest mistake new skill authors make is **building skills that do too much.** A skill that handles "everything related to PRs" won't trigger reliably because Claude can't match it cleanly against any specific prompt.
**Rule of thumb:** if you're using "and" in the description more than once, split the skill.
Bad:
```
description: Handles PR creation and PR review and PR merging and writing post-mortems for failed deployments.
```
Good (split into three skills):
```
description: Use when drafting a new pull request title and body...
description: Use when reviewing an open pull request against our checklist...
description: Use when writing a post-mortem for a failed deployment...
```
Small, sharp skills compose. Big, sprawling skills collide.
### Description writing: lead with the trigger
Your description is the _single signal_ Claude uses to decide whether to load your skill. Treat it like ad copy. The pattern that works:
```
Use when [user action or context]. [What the skill does]. [Disambiguator if needed].
```
Concrete examples:
```
Use when reviewing pull requests in our backend repos. Applies our security
checklist, naming conventions, and required test-coverage thresholds. Not for
frontend repos — see frontend-pr-review for those.
```
```
Use when drafting outbound sales emails to enterprise prospects. Applies our
voice (direct, no buzzwords), inserts the standard discovery-call CTA, and
respects the do-not-contact list in reference/exclusions.md.
```
### Invocation patterns: model-invoked vs explicit
Most skills should be **model-invoked** — Claude decides when to load them. But there are cases where you want explicit invocation:
- **Destructive or expensive operations.** A skill that runs migrations or deletes data shouldn't auto-fire.
- **Skills with overlapping triggers.** If two skills could plausibly fire on the same prompt, make one or both explicit.
For explicit-only skills, set `disable-model-invocation: true` in the frontmatter. **Default to model-invoked.**
### Tool restriction: the `allowed-tools` field
By default, a skill can use any tool the session has available. By listing tools, you restrict what the skill can do _while it's active._
```markdown
---
name: code-review-checklist
description: Use when reviewing pull requests...
allowed-tools: Read Grep Glob
---
```
This skill can read files and search them, but it cannot edit, write, or run bash commands.
When to restrict:
- **Read-only skills** (review, analysis): restrict to `Read Grep Glob`.
- **Skills that should never write code:** strip `Edit Write`.
- **Skills that should never shell out:** strip `Bash`.
Restrict by default; loosen by exception. It makes skills safer to share.
### Layering: keep SKILL.md lean
Anything you put in `SKILL.md` loads into context every time the skill activates. Reference files only load when Claude is told to read them.
Good layering:
- **`SKILL.md`** — the procedure, written tightly. Steps, examples, decision rules.
- **`reference/*.md`** — edge cases, deep dives, long examples, full style guides.
- **`scripts/*`** — anything procedural that's better as code than prose.
- **`templates/*`** — boilerplate Claude can copy and modify.
In your `SKILL.md`, link to the reference files explicitly: _"For unusual file types, see `reference/edge-cases.md`."_ Claude will load that file only when the situation calls for it.
### Testing: the trigger test
Before shipping any skill, run the **trigger test:**
1. Write down five prompts a real user would type to invoke this skill.
2. Write down three prompts a real user would type that should _not_ invoke it.
3. Run all eight in fresh Claude Code sessions.
4. Check whether the skill loaded in each case.
If the skill misses on prompts in group 1, the description is too narrow. If it fires on prompts in group 2, the description is too broad.
### The five-rule summary
1. **One skill, one job.** Split anything you describe with "and."
2. **Lead descriptions with the trigger.** "Use when..." beats "Helper for..."
3. **Restrict tools by default.** Use `allowed-tools` to scope what each skill can do.
4. **Layer aggressively.** Body lean, references deep.
5. **Test the trigger.** Five hits, three misses, fresh sessions.
---
## Sharing Claude Code Skills Across a Team
**A skill on one developer's laptop is useful. The same skill installed across an entire team is transformative — because every person's workflow improvement becomes everyone's workflow improvement.**
### Why team-shared Claude Code Skills compound
When one developer writes a skill that captures "how we review PRs at our company," three things happen:
1. **The author stops repeating themselves.** Every PR review session loads the same checklist automatically.
2. **The team's standards become enforceable.** Junior engineers get the same review depth as senior ones, because the skill is doing the consistency work.
3. **The skill improves through use.** When a teammate hits an edge case the skill missed, they update it — and now the _next_ hundred reviews benefit.
That's the compounding loop. One skill's value isn't its content; it's the rate at which it improves. Team-shared skills improve at team velocity. Personal skills improve at one-developer velocity.
### Three ways to share Claude Code Skills with a team
**1. Commit them to the repo (project-level skills)**
Drop skills in `.claude/skills/` inside the repo and commit them to git.
```
your-repo/
├── .claude/
│ └── skills/
│ ├── pr-review-checklist/
│ ├── migration-runner/
│ └── commit-message/
├── src/
└── package.json
```
**Pros:** Versioned with the codebase. New hires get them on first clone. Skill changes go through code review like everything else.
**Cons:** Only loads in that repo. Cross-repo skills (your company's voice, your security checklist) need a different approach.
**Best for:** Repo-specific conventions, project workflows, codebase-specific patterns.
**2. Distribute them as a plugin**
Plugins bundle skills (plus optional subagents, MCP configs, hooks, and slash commands) into one installable unit.
```
your-team-plugin/
├── .claude-plugin/
│ └── plugin.json
└── skills/
├── pr-review-checklist/
├── company-voice/
└── incident-postmortem/
```
**Pros:** One install command, available across all repos. Versioned independently. Easy to update everyone at once.
**Best for:** Cross-repo skills, company-wide conventions.
**3. Keep reviewed playbooks in shared workspace Files**
Instead of hiding team procedures in personal folders, keep reviewed instruction files and supporting scripts in a shared workspace. New members can read the same source on day one, and updates remain visible to the whole team. This is file sharing, not a skills installer; your team still owns versioning and review.
**Best for:** Growing teams where skill maintenance is starting to feel like a part-time job; agencies sharing skills across client engagements.
### What makes a skill worth sharing
Not every personal skill should be a team skill. The ones that compound across a team have three properties:
- **Generality.** It applies to more than one person's workflow.
- **Stability.** The procedure doesn't change every week.
- **Documentability.** You can describe the trigger in one sentence.
If a skill checks all three, it's a candidate. If it checks two, refine it before sharing.
### The starter library most teams converge on
Across the teams shipping Claude Code Skills in production, a recognizable starter set has emerged:
- **`pr-review-checklist`** — your team's review standards
- **`commit-message`** — Conventional Commits in your house style
- **`incident-postmortem`** — the template + tone for retros
- **`feature-spec`** — how to write a one-page feature spec
- **`migration-safety`** — pre-flight checks for schema changes
- **`code-style`** — your unwritten conventions, written down
- **`customer-comms`** — voice and templates for customer-facing writing
Seven skills. Each one captures a procedure that used to live in a wiki or a senior engineer's head. Together, they raise the floor for the whole team.
### Where Duet fits
If your team is small and disciplined, a `.claude-plugin` repo plus `git pull` is plenty. You don't need a platform; you need conventions.
If your team is growing — new hires every month, multiple repos, skills proliferating, no clear owner — the operational cost of skill maintenance starts to add up. That's the point where shared Files, an explicit review owner, durable Train context, and visible session history start paying for themselves.
[Duet](/?utm_source=blog&utm_medium=organic&utm_campaign=claude-code-skills-guide) gives the team one persistent workspace for reviewed instruction files, supporting code, and durable business context. The files remain visible and versionable instead of disappearing into a proprietary catalog.
The bigger point: **whatever distribution mechanism you pick, ship skills as a team primitive, not a personal one.** That's where the compounding lives.
---
## Where to Find Claude Code Skills
**The Claude Code Skills ecosystem went from grassroots to industry-standard in roughly six months — there are now thousands of community-built skills, official Anthropic skills, and vetted third-party libraries.**
### Official sources (start here)
| Source | What's there | URL |
| ------------------------------ | ------------------------------------------------------------ | -------------------------------------------------------------------- |
| **Anthropic Skills GitHub** | Official skills: `skill-creator`, `pdf-reader`, `claude-api` | [github.com/anthropics/skills](https://github.com/anthropics/skills) |
| **Claude Plugins Marketplace** | Curated plugins bundling skills + MCP + subagents | [claude.ai/marketplace](https://claude.ai/marketplace) |
| **Anthropic docs** | Format spec, API reference, migration guides | [docs.anthropic.com](https://docs.anthropic.com) |
If a skill exists officially, use the official version. It will be maintained, security-reviewed, and compatible with future format changes.
### Community sources
- **agentskills.io** — community directory tracking the open standard.
- **SkillsMP** ([skillsmp.com](https://skillsmp.com/)) — third-party marketplace with skills for Claude, Codex, and ChatGPT.
- **Hugging Face skills repository** — open-source skills, many AI/ML focused.
- **GitHub topic search** — `topic:claude-code-skill` and `topic:agent-skill` surface community repos.
These move faster but vary in quality. Treat them like any open-source dependency: read before you install.
### How to install a Claude Code Skill
**Direct copy (single skill)**
```bash
# User-level install (available everywhere)
cp -r path/to/cloned-skill ~/.claude/skills/
# Project-level install (this repo only)
cp -r path/to/cloned-skill .claude/skills/
```
Restart your Claude Code session and the skill appears.
**Plugin install**
```bash
claude plugins install
claude plugins install github.com//
```
Plugins bundle skills with subagents, MCP configs, and hooks, so a single install can extend your environment substantially.
**Through a managed platform**
In a managed workspace such as Duet, teams can keep reusable instructions and supporting scripts in shared workspace files, while Train owns durable business facts and sources. A dedicated skills-management screen is not part of the current Duet release.
### How to vet a Claude Code Skill before installing
Skills aren't passive content. They're instructions Claude will follow, sometimes with access to your codebase, your shell, and your credentials. Treat them like dependencies.
- **Read the `SKILL.md` file end to end.** If you can't read the procedure, you don't know what the skill will do.
- **Check the `allowed-tools` field.** A skill that requests `Bash`, `Edit`, and `Write` is doing more than reading.
- **Inspect bundled scripts.** A skill that runs `curl | sh` should be a hard no.
- **Check the trigger description.** Will this skill activate on prompts you don't intend?
- **Look at the source.** First-party Anthropic > established author > random GitHub repo with no stars.
- **Test in a sandbox first.** Install to a project-level `.claude/skills/` in a throwaway repo before promoting to user-level.
### Curating your skill library
- **Audit quarterly.** Run through `~/.claude/skills/` and remove anything you haven't used in 90 days.
- **Keep a `README.md` in your skills folder.** Document which skills you have, where they came from, and what they're for.
- **Don't install everything.** A skill you might use someday is a skill that adds 100 tokens of discovery overhead today.
---
## Stop Teaching Claude the Same Thing Twice
If you're a solo developer, start small: build one skill for a procedure you repeat weekly, install [Anthropic's `skill-creator`](https://github.com/anthropics/skills), and let your library grow organically.
If you're a team, the bigger lever is **shared skills.** The fastest way to capture team knowledge isn't another Notion doc — it's a skill that activates on the exact prompts your developers are already typing.
[Duet](/pricing?utm_source=blog&utm_medium=organic&utm_campaign=claude-code-skills-guide) gives your team a shared workspace where reviewed instruction files and supporting scripts are available to members. Store them in Files, keep stable business sources in Train, and use Sessions as the durable record of execution.
[**See how Duet handles shared workspace context →**](/pricing?utm_source=blog&utm_medium=organic&utm_campaign=claude-code-skills-guide)
---
## Frequently Asked Questions About Claude Code Skills
### What are Claude Code Skills and how do they work?
Claude Code Skills are folders containing a `SKILL.md` file plus optional scripts and reference files. Each skill teaches Claude how to perform a specific task in a repeatable way. Skills are **model-invoked** — Claude reads each skill's name and description (~100 tokens per skill) on every session, then loads the full skill body (up to ~5K tokens) only when your prompt matches. This is called progressive disclosure, and it's why you can have dozens of skills installed without slowing down Claude Code.
### Claude Code Skills vs MCP: when do I use which?
Use Skills for **procedural knowledge** (how to do something) and MCP for **access** (connecting Claude to external systems like GitHub, databases, or APIs). A typical setup uses both: an MCP server gives Claude access to your GitHub, and a skill tells Claude how to review PRs against your team's standards. MCP is more expensive in context — a typical 5-server setup uses ~55,000 tokens before any conversation starts. Skills cost ~100 tokens per skill until activated.
### Claude Code Skills vs Subagents: what's the difference?
Skills are reusable instructions loaded into your main Claude session. Subagents are independent specialists with their own context window, tools, and sometimes their own model (Sonnet, Haiku, etc.). Use a skill when you want Claude to follow a procedure. Use a subagent when you want to delegate work to a specialist who runs separately — like a code reviewer with read-only access, or a research agent on Haiku. Subagents can call skills, which is the most powerful pattern in Claude Code.
### How do I write a good SKILL.md?
A good `SKILL.md` has three things:
1. A **YAML frontmatter description** that starts with "Use when..." and is specific enough that Claude knows exactly when to invoke it.
2. A **body under 500 lines** with clear instructions, when-to-use and when-not-to-use sections, and concrete examples.
3. **Reference files** in subfolders for anything long-form (edge cases, full style guides, scripts) so the body stays lean.
The single most important field is the description. If your skill isn't firing, the description is wrong — not the body.
### Where can I find Claude Code skill examples?
Start with **Anthropic's official repo at** [github.com/anthropics/skills](https://github.com/anthropics/skills) for first-party skills like `skill-creator`, `pdf-reader`, and `claude-api`. The **Claude Plugins marketplace** has curated plugins that bundle multiple skills. Community sources include **agentskills.io**, **SkillsMP** ([skillsmp.com](https://skillsmp.com/)), and GitHub repos tagged with the `claude-code-skill` topic.
### How many Claude Code Skills can I have installed at once?
Practically unlimited. Because of progressive disclosure, each idle skill costs only ~100 tokens. Most production setups have 5–10 skills tailored to the team's workflow. Power-user setups with 30+ skills run without context issues — the bigger limit is human cognitive load (knowing what's installed) rather than token cost.
### Can Claude Code Skills be shared across a team?
Yes — three ways. **Project-level skills** in `.claude/skills/` are committed to a repo and travel with the codebase. **Plugins** bundle skills (and other primitives) into installable packages, ideal for cross-repo company conventions. A persistent workspace like [Duet](/pricing?utm_source=blog&utm_medium=organic&utm_campaign=claude-code-skills-guide) can keep reviewed instruction files and scripts in shared Files, but your team still owns versioning and review.
### Are Claude Code Skills compatible with other AI coding agents?
Yes. The Agent Skills specification was open-sourced by Anthropic in December 2025 and adopted by OpenAI for Codex CLI and ChatGPT. The same `SKILL.md` format also works with Gemini CLI, Cursor, and other compatible agents. Build a skill once, run it across every agent your team uses.
### What's the difference between Claude Code Skills and slash commands?
**Slash commands** are user-invoked — you explicitly type `/command-name` to trigger them. **Skills** are model-invoked — Claude decides when to load them based on your prompt and the skill's description. Slash commands are good for explicit, on-demand actions. Skills are good for context-aware automation that should happen without the user having to remember a command.
### Do Claude Code Skills work in the Claude API?
Yes. Skills are part of the Agent Skills specification and work across Claude Code, Claude.ai, and the Anthropic API. The same `SKILL.md` file works in all three — you don't need to rewrite skills for different surfaces.
### How do I update a Claude Code Skill across my whole team at once?
It depends on your distribution method. **Project-level skills** update via normal git workflow — commit, push, teammates pull. **Plugin-based skills** require a plugin version bump and a `claude plugins update` on each developer's machine. **Managed platforms** push updates centrally — change the skill once in the workspace, everyone gets it instantly.
### Can a Claude Code Skill execute code?
Yes. Skills can bundle scripts (Python, Bash, Node — anything available in the runtime) and instruct Claude to call them. This is useful for tasks where prose instructions are weaker than actual code — file format conversions, API calls with complex authentication, deterministic operations. The `allowed-tools` field controls what tools the skill can use while active, including `Bash` for shell access.
---
Source: https://duet.so/guides/claude-code-vs-claude-cowork
# Claude Code vs Claude Cowork Comparison
*Compare Claude Code and Claude Cowork — what each does best, key differences, and when to use which for your workflow.*
By Sawyer Middeleer. Published 2026-03-05, updated 2026-05-08. 13 min read.
Claude Code and Claude Cowork are both agentic AI tools from Anthropic, but they're built for completely different users and workflows. Code is a developer tool that lives in your terminal and writes software. Cowork is a productivity tool that lives in the Desktop app and handles knowledge work — documents, research, file management, and business workflows. Same Claude brain, different hands.
This guide breaks down what each does, where each excels, and how to decide which one fits your work.
---
## 1. Quick Comparison
| | Claude Code | Claude Cowork |
| -------------------------- | --------------------------------- | ------------------------------------------------- |
| **Built for** | Software developers | Knowledge workers (marketing, ops, finance, etc.) |
| **Interface** | Terminal CLI, VS Code, JetBrains | Claude Desktop app (macOS, Windows) |
| **Primary output** | Code, git commits, PRs, tests | Documents, spreadsheets, presentations, research |
| **File access** | Full codebase via terminal | Granted folders via Desktop app |
| **External tools** | MCP servers (manual setup) | Connectors (built-in marketplace) |
| **Extensibility** | Skills, hooks, plugins, subagents | Skills, plugins, connectors, slash commands |
| **Automation** | CI/CD, git hooks, external cron | Built-in `/schedule` command |
| **Runs on** | Your machine (terminal session) | Your machine (Desktop app VM) |
| **Subscription** | Pro ($20/mo), Max, or API | Pro ($20/mo), Max, Team, or Enterprise |
| **Technical skill needed** | Moderate to high | None |
---
## 2. What is Claude Code?
[Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) is Anthropic's agentic coding tool. It connects Claude directly to your terminal, giving it the ability to read entire codebases, write and edit files across multiple directories, run commands, manage git workflows, and execute complex multi-step development tasks.
You describe what you want built — a feature, a bug fix, a refactor — and Claude plans the implementation, writes the code, runs tests, and commits the changes. You stay in control through approval steps, but the tool handles the heavy lifting.
Claude Code runs in the terminal (CLI) and integrates with VS Code, JetBrains, and GitHub. It's designed for people who already write code and want an AI partner that understands their codebase deeply.
For the full setup walkthrough, see [Claude Code for Founders](/guides/claude-code-for-founders).
---
## 3. What is Claude Cowork?
[Claude Cowork](https://support.claude.com/en/articles/13345190-get-started-with-cowork) is Anthropic's agentic productivity tool for knowledge work. It runs inside the Claude Desktop app and can read your files, create polished documents, research the web, build Excel spreadsheets with working formulas, generate PowerPoint presentations, and coordinate complex multi-step workflows.
You describe the outcome you want — organize these files, turn meeting notes into a report, research competitors and build a comparison matrix — and Claude breaks the work into subtasks, executes them (often in parallel), and delivers finished output directly to your file system.
Cowork runs in an isolated virtual machine on your desktop. No terminal required, no coding knowledge needed. It's designed for marketers, operations leads, analysts, founders, and anyone who does knowledge work on a computer.
For the full setup walkthrough, see [Claude Cowork: Complete Beginner's Guide](/guides/claude-cowork-for-beginners).
---
## 4. Key Differences
### Interface and Access
The most obvious difference is where you interact with each tool.
**Claude Code** lives in the terminal. You type commands, read output, and approve file changes through a text-based interface. It also embeds into VS Code and JetBrains as an IDE extension. If you're comfortable with `cd`, `git`, and `npm`, Code will feel natural.
**Cowork** lives in the Claude Desktop app. You switch to the Cowork tab, grant folder access through a GUI, and describe tasks in plain English. The interface shows task progress visually. If you can use a chat app, you can use Cowork.
### File System Access
**Claude Code** has unrestricted access to your project directory and can navigate your entire file system through the terminal. It reads codebases, modifies source files, creates directories, and runs any shell command you approve.
**Cowork** only accesses folders you explicitly grant permission to. It runs inside a sandboxed VM, which adds a layer of safety but limits it to designated working directories.
### Output Types
**Claude Code** produces code. JavaScript, Python, TypeScript, Rust, SQL, Terraform — any programming language or config format. Its output goes into source files, gets committed to git, and ships through CI/CD pipelines.
**Cowork** produces documents. Excel spreadsheets with formulas, PowerPoint decks, formatted PDFs, research reports, organized file structures. Its output goes into your file system as finished deliverables.
### Extensibility Model
Both tools support extensibility, but through different mechanisms:
**Claude Code** extends via MCP servers (manual setup in config files), skills (Markdown files in `.claude/skills/`), hooks (shell commands triggered by events), subagents (specialized agents for delegation), and plugins (bundles of all the above). The ecosystem is developer-oriented — you configure things via JSON files and the terminal.
**Cowork** extends via connectors (browse and install from a built-in marketplace), plugins (bundles of skills, connectors, and slash commands), and context files (Markdown instructions in your folders). The ecosystem is user-oriented — most setup happens through the app's settings UI.
### Automation
**Claude Code** has no built-in scheduling. To run tasks automatically, you need external tooling — cron jobs, CI/CD triggers, or a wrapper like the Claude Agent SDK. This gives developers maximum flexibility but requires setup.
**Cowork** has built-in scheduling via the `/schedule` slash command. You can set up recurring tasks directly in the app. The catch: your computer must be awake and the app must be open for scheduled tasks to execute.
---
## 5. Where Claude Code Excels
### Complex Software Development
This is Claude Code's core strength. It reads entire codebases — understanding file relationships, import chains, type systems, and architectural patterns — then plans and executes multi-file changes. Ask it to refactor an authentication system, add a new API endpoint with tests, or migrate a database schema, and it will work through the entire task methodically.
### Git Workflow Integration
Claude Code understands git deeply. It creates branches, stages changes, writes commit messages, pushes to remotes, and can even create pull requests via the GitHub CLI. For developers, this means the full loop from "describe the feature" to "PR ready for review" happens in one session.
### Terminal and System Operations
Because Code runs in the terminal, it can do anything your shell can do — run test suites, start dev servers, install packages, check logs, debug build failures, query databases. This makes it invaluable for DevOps work, debugging, and system administration.
### IDE Integration
The VS Code and JetBrains extensions bring Claude Code into your existing workflow. You don't have to leave your editor — invoke Claude inline, see file changes in diff view, and approve modifications without switching windows.
### Agent SDK and Custom Agents
The Claude Agent SDK lets developers build entirely custom agentic systems on top of Claude Code's infrastructure. If you're building an AI product or internal tool, Code provides the foundation — context management, tool registration, session handling, and multi-agent orchestration.
For deeper coverage of Claude Code's capabilities, see [Claude Code for Founders](/guides/claude-code-for-founders) and the [skills architecture guide](/guides/agent-skills-101-tools-vs-mcp-vs-skills).
---
## 6. Where Cowork Excels
### Document Creation
Cowork generates real files — not text descriptions of files. Ask for an Excel spreadsheet and you get a `.xlsx` with working formulas, formatted cells, and multiple sheets. Ask for a presentation and you get a `.pptx` with proper layouts. Claude Code can't do this; it produces code, not office documents.
### Non-Technical Accessibility
Cowork requires zero technical knowledge. No terminal, no command line, no configuration files (unless you want them). The entire experience — from granting folder access to reviewing task output — happens through a visual interface. This opens Claude's agentic capabilities to marketing teams, operations leads, executives, and anyone who doesn't code.
### File Organization and Management
Cowork excels at the kind of file work that's tedious for humans: sorting hundreds of files by type, renaming with consistent conventions, deduplicating, creating indexes, and restructuring folder hierarchies. Claude Code technically can do this through shell commands, but Cowork makes it a natural first-class workflow.
### Research and Synthesis
Give Cowork a research question and it breaks it into sub-queries, searches the web, synthesizes findings across multiple sources, and produces a structured report with citations. It handles the entire pipeline — from question to deliverable — without you needing to guide each step.
### Built-In Connectors
Cowork's connector marketplace makes external integrations accessible without technical setup. Browse available connectors, click to authenticate, and Claude can pull data from Salesforce, Notion, Slack, or dozens of other tools. Claude Code's MCP integrations offer more flexibility but require manual configuration.
### Scheduled Automation
The `/schedule` command gives non-technical users access to recurring automation without writing cron expressions or setting up external services. "Generate a weekly expense summary every Monday" is all it takes.
For the full Cowork walkthrough, see [Claude Cowork: Complete Beginner's Guide](/guides/claude-cowork-for-beginners).
---
## 7. Use Case Breakdown
### Use Claude Code When...
| Use Case | Why Code |
| --------------------------- | ----------------------------------------------------------- |
| Building a web app or API | Full codebase understanding, git integration, test running |
| Fixing bugs in production | Can read logs, check error traces, modify source, run tests |
| Refactoring a codebase | Multi-file changes with type system awareness |
| Setting up CI/CD pipelines | Terminal access, infrastructure config files |
| Building custom AI agents | Agent SDK, tool registration, context management |
| DevOps and system admin | Shell access, log analysis, service management |
| Contributing to open source | Git workflow, PR creation, code review |
### Use Cowork When...
| Use Case | Why Cowork |
| ---------------------------------------- | ------------------------------------------------------------ |
| Creating reports and presentations | Real `.xlsx` and `.pptx` output with formulas and formatting |
| Organizing messy file systems | First-class file management with visual progress |
| Market research and competitive analysis | Web research, synthesis, structured output |
| Meeting notes to action items | Document parsing, email drafting, task extraction |
| Expense tracking and data entry | Receipt processing, spreadsheet creation |
| Content drafting and editing | Document creation in your brand voice (via context files) |
| CRM data pulls and analysis | Built-in connectors to Salesforce, HubSpot, etc. |
| Recurring business workflows | Built-in scheduling without technical setup |
### When Either Could Work
Some tasks sit in the overlap zone:
- **Data analysis** — Code if you're writing Python/R scripts; Cowork if you want Excel output
- **Automation** — Code if you need 24/7 reliability with external cron; Cowork if desktop-hours scheduling is sufficient
- **Web scraping** — Code via terminal tools; Cowork via web browsing capabilities
- **Writing** — Code can generate Markdown content for static sites; Cowork produces formatted documents
---
## 8. Can You Use Both?
Yes, and many power users do. The typical split:
- **Claude Code** for anything that involves a codebase, git, or the terminal
- **Cowork** for everything else — documents, research, file management, business workflows
They share the same Claude subscription and the same underlying models. The difference is the interface and the type of work each is optimized for.
Claude Code and Cowork share your subscription's usage allocation. Heavy use of one reduces what's
available for the other. If you're hitting limits, consider Claude Max ($100-200/month) for higher
caps.
### What Neither Does Well
Both tools run locally and stop when you close the session (Code) or the Desktop app (Cowork). Neither provides:
- **Persistent 24/7 operation** without your machine running
- **Team collaboration** where multiple people interact with the same agent
- **Cloud-native deployment** of apps and services
For always-on AI agents with persistent memory, durable team sessions, and cloud infrastructure, a platform like [Duet](/) fills that gap — running coding agents and other models on a dedicated cloud server that does not depend on your laptop.
---
## 9. FAQ
**Do I need separate subscriptions for Code and Cowork?**
No. Both are included with any paid Claude subscription — Pro ($20/month), Max ($100-200/month),
Team, or Enterprise. They share the same usage allocation, so heavy use of one affects
availability of the other.
**Do they use the same AI model?**
Yes. Both Claude Code and Cowork run on the same Claude models (Opus, Sonnet, Haiku). The
difference is the interface and tooling, not the underlying intelligence. A task given to Code
and Cowork with the same prompt would get the same quality reasoning — just different output
formats.
**Can I switch between Code and Cowork in the same session?**
Not in the same session — they're separate modes in the Claude Desktop app (Chat, Cowork, Code
tabs). However, you can switch modes freely between tasks. There's no penalty or setup cost for
going back and forth.
**Can Cowork write code?**
Cowork can generate code files and scripts, but it's not designed for software development. It
doesn't understand codebases holistically, doesn't integrate with git, and can't run test suites
or dev servers. For anything beyond simple scripts, use Claude Code.
**Can Claude Code create Excel or PowerPoint files?**
Claude Code can generate files through code — for example, writing a Python script that uses
`openpyxl` to create an Excel file. But it doesn't natively produce office documents the way
Cowork does. If you want a formatted spreadsheet without writing code to generate it, use
Cowork.
**Which is better for teams?**
Neither is built for team collaboration — both run locally on individual machines. Claude Code
has no sharing mechanism at all. Cowork on Team and Enterprise plans adds admin controls and
connector approval, but sessions themselves aren't shared. For team-based AI workflows where
multiple people interact with the same agent, you'd need a cloud-based solution like [Duet](/).
**I'm not technical — should I start with Cowork?**
Yes. Cowork is designed for non-technical users and requires no coding knowledge. Start with
simple tasks (file organization, document creation), build up your context files, and explore
plugins as you get comfortable. If you later want to try Claude Code, the [beginner's
guide](/guides/claude-code-for-founders) walks you through setup step by step.
**Can I use either on mobile?**
No. Claude Code requires a terminal (macOS, Linux, Windows with WSL). Cowork requires the Claude
Desktop app (macOS or Windows x64). Neither has a mobile or web interface. The regular Claude
chat at claude.ai works on mobile, but it doesn't have Code or Cowork's agentic capabilities.
---
Source: https://duet.so/guides/claude-cowork-for-beginners
# Claude Cowork: Complete Beginner's Guide
*Learn Claude Cowork from scratch. Setup, context files, plugins, connectors, scheduled tasks, and practical workflows for non-technical users.*
By Sawyer Middeleer. Published 2026-03-05, updated 2026-05-08. 19 min read.
Quick Summary
This beginner's guide covers everything you need to know about Claude Cowork. What it is, how it differs from Claude Code, how to set it up, and how to run your first agent workflow with no prior AI agent experience required.
Questions this page answers
- What is Claude Cowork?
- How does Claude Cowork work?
- Claude Cowork beginner guide
- How to get started with Claude Cowork
- What is the difference between Claude Code and Claude Cowork?
Claude Cowork is a collaborative workspace built on top of Claude that lets teams interact with AI in shared, persistent sessions rather than individual one-off chats. Unlike standard Claude, Cowork maintains context across sessions, supports multiple team members in the same workspace, and can be configured with custom instructions and tools for your specific workflows.
## What is Claude Cowork? A Beginner's Guide to Agentic AI for Non-Developers
Claude Cowork is Anthropic's agentic productivity tool built into the Claude Desktop app. It turns Claude from a chatbot into a digital coworker that can read your files, create documents, research the web, and execute multi-step tasks on your computer, all without writing a single line of code.
Unlike standard Claude chat where you go back and forth one message at a time, Cowork can take initiative. Ask it to organize your downloads folder, turn meeting notes into a formatted report, or research competitors and build a comparison spreadsheet, and it will plan the work, execute across multiple steps, and deliver finished output directly to your file system.
### Why Use Claude Cowork Instead of Regular Claude Chat?
In regular Claude chat, you paste content in and copy answers out. In Cowork, you describe what you want done, point Claude at your files, and supervise while it does the work. It can read entire folders, create polished Excel spreadsheets with working formulas, build PowerPoint presentations, and coordinate complex research, the kind of work that normally takes hours of manual effort.
If Claude Code is built for developers, Cowork is built for everyone else. For a detailed side-by-side breakdown, see Claude Code vs Claude Cowork.
---
## How to Install and Set Up Claude Cowork on Mac or Windows
Getting started with Cowork takes about five minutes. You need the Claude Desktop app and a paid subscription.
### What You Need to Get Started with Claude Cowork
1. Claude Desktop app: download from [claude.ai/download](https://claude.ai/download)
1. Paid Claude subscription: Pro ($20/month), Max ($100-200/month), Team, or Enterprise
Cowork is available on macOS and Windows (x64). If you're on Windows with an ARM processor, you'll need to wait for ARM support.
### How to Install Claude Cowork on Mac and Windows
Mac:
1. Go to [claude.ai/download](https://claude.ai/download) and download the macOS installer
1. Open the `.dmg` file and drag Claude to your Applications folder
1. Launch Claude Desktop and sign in with your paid account
Windows:
1. Go to [claude.ai/download](https://claude.ai/download) and download the Windows installer
1. Run the installer and follow the prompts
1. Launch Claude Desktop and sign in
### How to Switch to Cowork Mode in Claude Desktop
Once Claude Desktop is open, you'll see tabs at the top of the window: Chat, Cowork, and Code. Click Cowork to switch modes.
That's it. You're in Cowork.
---
## Getting Started with Claude Cowork: Your First Task in 5 Minutes
### Your First Claude Cowork Task: A Step-by-Step Walkthrough
The best way to learn Cowork is to give it something real to do. But start with a test folder - don't point it at critical files while you're still learning.
1. Create a folder called `Claude_Test` in your Documents
1. Add a few non-sensitive files, old documents, sample spreadsheets, random notes
1. In Cowork, grant access to this folder when prompted
1. Try a simple task: "Organize these files by topic and create a summary document listing what's in each category"
Claude will analyze your files, create a plan, and execute it. You'll see its progress in real time and can steer it if needed.
### How to Grant Claude Cowork Access to Your Files and Folders
Cowork runs inside an isolated virtual machine on your computer for safety. It can only access folders you explicitly grant permission to. When you start a task that involves files, Claude will ask which folders it can work with.
Start narrow. Grant access to one specific project folder rather than your entire Documents
directory. You can always add more folders later.
### What Claude Cowork Can Do: 5 Core Capability Areas
Cowork excels at five categories of work:
## How to Work With Claude Cowork: Tasks, Prompts, and Approvals
### How Claude Cowork Tasks Work: Plan, Execute, Deliver
When you describe a task, Cowork follows a consistent pattern:
1. Analyzes your request and asks clarifying questions if needed
1. Plans the work, breaking it into subtasks
1. Executes each subtask, often running multiple in parallel
1. Delivers output directly to your file system
You maintain visibility throughout. Cowork shows you what it's doing at each step, and you can redirect it mid-task if something isn't right.
### Prompting Claude Cowork: How to Write Instructions That Get Results
Interacting with Cowork is similar to chatting with Claude, but with one key difference: you're describing outcomes, not asking questions.
Good prompts describe what you want done:
- "Take these 12 customer interview transcripts and extract the top 5 recurring themes with supporting quotes"
- "Create an Excel spreadsheet tracking our Q1 marketing spend by channel, with formulas for totals and month-over-month change"
- "Research the top 10 project management tools, compare features and pricing, and create a recommendation memo"
Less effective prompts are vague:
- "Help me with my files" (which files? what help?)
- "Do something with this data" (what output do you want?)
Cowork consumes more of your usage allocation than regular chat because it runs multi-step agentic
workflows. For simple questions, use standard Chat mode instead.
### Claude Cowork Approval Steps: Staying in Control of Your Agent
Cowork asks for your approval before taking significant actions - especially anything that deletes files or accesses sensitive data. Review these carefully.
A good default: always tell Claude "don't delete anything" unless you specifically want deletions. This prevents accidental data loss while you're learning.
### The Scope-Plan-Execute Flow: The Best Way to Run Complex Cowork Tasks
For complex work, the most reliable approach mirrors how you'd brief a new hire:
Scope: Start by having a conversation about what you need. Share context, show examples of good output, clarify constraints.
Plan: Ask Claude to write out its plan before executing. Review it. Adjust anything that looks off.
Execute: Once the plan looks right, tell Claude to proceed. Monitor the first few steps, then let it run.
This is iterative. After the first pass, review output, give feedback, and have Claude refine.
## Claude Cowork Context Files: How to Give Your Agent Persistent Instructions
This is the single most important section of this guide. Cowork out of the box is mediocre. Cowork with proper context files is a different tool entirely. The gap between those two experiences is about 30 minutes of setup.
### Why Context Files Are the Most Important Part of Claude Cowork
Cowork has no memory between sessions. Every conversation starts completely fresh. It doesn't know who you are, what your company does, or how you like things formatted. Without context, it produces generic output.
The fix is context files, documents that live in your project folders and tell Claude everything it needs to know to do good work.
### Global Instructions in Claude Cowork: Set It Once, Apply Everywhere
Navigate to Settings > Cowork and click Edit next to Global Instructions. These apply to every Cowork session regardless of which folder you're working in.
Good global instructions include:
```markdown
# About Me
- Name: [Your name]
- Role: [Your role] at [Company]
- I prefer concise, direct communication
# Output Preferences
- Always use tables for comparisons
- Default to bullet points over paragraphs
- Include sources when citing research
- Save output files with descriptive names (not "output.xlsx")
# Safety
- Never delete files without asking first
- Always confirm before sending any emails or messages
```
### Folder-Level Instructions: Project-Specific Context for Claude Cowork
When you grant Cowork access to a folder, you can add folder-specific instructions. These act like a project brief that Claude reads at the start of every session involving that folder.
For example, a marketing folder might include:
```markdown
# Marketing Team Context
- Brand voice: Professional but approachable. Never use jargon.
- Target audience: SMB founders (1-50 employees)
- Competitors: [list]
- Style guide: See brand-guidelines.pdf in this folder
# Common Tasks
- Weekly reports use the template in /templates/weekly-report.xlsx
- Blog drafts go in /drafts/ with the naming format YYYY-MM-DD-title.md
```
Context files compound over time. Start basic, then add notes each time Claude produces output
that isn't quite right. After a few sessions, output quality improves dramatically.
### What to Include in Your Claude Cowork Context Files
## Claude Cowork Skills: How to Teach Your Agent Custom Workflows
### What Are Claude Cowork Skills and How Do They Work?
Skills are written instructions that teach Claude how to do something specific. Think of them as SOPs (Standard Operating Procedures) that Claude follows when it encounters a matching task.
A skill might teach Claude how to:
- Write blog posts in your company's voice
- Format financial reports following your template
- Run a specific research workflow step by step
- Prepare meeting agendas from your calendar
Skills are just Markdown files. No coding required. You describe the process in plain English, and Claude follows the instructions whenever the skill is relevant.
### How Skills Work Inside Claude Cowork Sessions
Skills live inside plugins (more on those in section 7). When you install a plugin, its skills become available to Claude automatically. You can also trigger skills explicitly using slash commands - type / followed by the command name.
For example, the open-source knowledge-work-plugins from Anthropic include skills for:
- Sales: Call prep, deal analysis, pipeline reviews
- Marketing: Content creation, competitive analysis, campaign planning
- Finance: Expense categorization, report generation, reconciliation
- Research: Literature reviews, market analysis, trend synthesis
### How to Create Your Own Claude Cowork Skills (No Coding Required)
You don't need to be technical to create skills. The simplest approach:
1. Do a task manually with Claude once and get the output right
1. Ask Claude: "Turn what we just did into a reusable skill"
1. Claude generates the skill Markdown file
1. Install it as part of a plugin
For a deeper dive on skill design, see Agent Skills 101: Tools vs MCP vs Skills.
## Claude Cowork Connectors: Linking Your Agent to Slack, Gmail, and More
### What Are Claude Cowork Connectors? (MCP Explained Simply)
Connectors link Claude to external services and data sources. Without connectors, Cowork can only work with files on your computer and browse the web. With connectors, it can pull data from your CRM, post to Slack, query databases, and interact with dozens of business tools.
Connectors use the Model Context Protocol (MCP), the same standard that powers tool integrations across the Claude ecosystem.
### Available Claude Cowork Connectors: Supported Tools and Services
Cowork supports connectors for many popular tools:
### How to Set Up a Claude Cowork Connector Step by Step
1. Open Claude Desktop and go to Settings > Connectors
1. Click Browse connectors to see what's available
1. Select a connector and follow the authentication flow
1. Once connected, Claude can access that service during Cowork tasks
On Team and Enterprise plans, connectors may require admin approval before individual users can
connect. Check with your IT admin if a connector isn't available.
### Using Claude Cowork Connectors in Real Workflows
Once a connector is set up, just reference it naturally in your tasks:
- "Pull our Q1 sales data from Salesforce and create a trend analysis"
- "Check Slack #marketing for messages about the product launch and summarize the key decisions"
- "Create a Jira ticket for each action item in these meeting notes"
Claude knows which connector to use based on context. You don't need to specify technical details.
## Claude Cowork Plugins: Bundling Skills, Connectors, and Slash Commands
### What Are Claude Cowork Plugins and Why Do They Matter?
Plugins are bundles that package skills, connectors, slash commands, and sub-agents together into a single installable unit. If skills are individual SOPs, plugins are entire departments.
A sales plugin might include:
- Skills: How to research accounts, prepare for calls, write follow-up emails
- Connectors: CRM integration, LinkedIn data, email
- Slash commands: `/sales:call-prep`, `/sales:deal-review`, `/sales:pipeline`
- Sub-agents: Specialized Claude instances for specific sub-tasks
### Why Plugins Are the Best Way to Share Skills Across Your Team
Without plugins, you'd set up each skill, connector, and workflow manually. Plugins solve three problems:
1. Bundling: everything a workflow needs in one package
1. Sharing: install the same plugin on every team member's machine
1. Versioning: update the plugin when workflows change, rather than editing config files
### How to Find and Install Claude Cowork Plugins
Anthropic maintains an open-source repository of plugins at github.com/anthropics/knowledge-work-plugins. These cover common knowledge work tasks across sales, marketing, finance, and general productivity.
To install a plugin from the marketplace:
1. Open the plugin browser in Claude Desktop
1. Search or browse available plugins
1. Click to install
To install from the command line:
```bash
claude plugins add knowledge-work-plugins/sales
```
### Understanding Claude Cowork Plugin Structure and Configuration
Under the hood, plugins are just folders containing Markdown files and a bit of JSON configuration:
```plaintext
my-plugin/
├── plugin.json # Plugin metadata
├── mcp.json # Connector configuration
├── commands/ # Slash commands
│ ├── call-prep.md
│ └── deal-review.md
└── skills/ # Skills and instructions
├── research.md
└── email-drafting.md
```
You can inspect, edit, and customize any plugin after installing it. They're designed to be transparent and modifiable.
### How to Build a Custom Claude Cowork Plugin for Your Team
The fastest way to build a plugin is to use the cowork-plugin-management plugin (yes, there's a plugin for managing plugins). Install it, then ask Claude to help you create a new plugin for your specific workflow.
For the complete guide to building plugins, see Beyond Claude Code: Building a Shared Skill Library, the same principles that apply to Claude Code skills apply to Cowork plugins.
## Claude Cowork Scheduled Tasks: Automating Recurring Workflows
### What Are Claude Cowork Scheduled Tasks?
Scheduled tasks let Claude run workflows automatically on a recurring basis, daily reports, weekly data pulls, automated file organization, or any other repeatable task.
### How to Set Up Scheduled Tasks in Claude Cowork
Use the /schedule slash command inside any Cowork task to set up automation:
- "Generate a weekly expense summary every Monday at 9am from the receipts in my /finances folder"
- "Every Friday, compile a status report from my project notes and save it to /reports"
You can manage scheduled tasks from the Scheduled option in the Cowork sidebar.
### Claude Cowork Scheduled Task Limitations: What to Know Before You Automate
Scheduled tasks only run when:
- Your computer is awake (not sleeping or shut down)
- The Claude Desktop app is open
If your machine is off when a task is scheduled, it won't execute. For workflows that need to run 24/7 regardless of whether your computer is on, you need a cloud environment.
Cowork's scheduled tasks depend on your desktop being open. If you need always-on automation cron jobs, webhook listeners, background monitoring, a cloud-based agent environment like Duet provides a persistent server that runs even when your laptop is closed.
## 10 Practical Claude Cowork Workflows for Knowledge Workers
Here are practical workflows that showcase what Cowork does best. Each can be set up in under 30 minutes.
### Claude Cowork for File Organization: Sort and Rename at Scale
Point Cowork at a messy folder, your Downloads, Desktop, or a shared drive - and ask it to:
- Sort files by type, project, or date
- Rename files with consistent naming conventions
- Create an index document listing everything and where it went
- Identify and flag duplicates
### Claude Cowork for Meeting Notes: Turn Transcripts into Action Items
After a meeting, drop the transcript or your rough notes into a folder and ask Cowork to:
- Extract action items with owners and deadlines
- Create follow-up email drafts for each participant
- Update your project tracker (via connectors)
- Generate a formatted summary for stakeholders
### Claude Cowork for Research and Analysis: From Question to Report
Give Cowork a research question and let it:
- Search the web for relevant sources
- Synthesize findings into a structured report
- Create comparison tables with specific data points
- Generate charts and visualizations from the data
### Claude Cowork for Expense Reports: Extract, Categorize, and Summarize
Drop receipts (photos, PDFs, emails) into a folder and ask Cowork to:
- Extract vendor, amount, date, and category from each receipt
- Build an Excel spreadsheet with all expenses categorized
- Add formulas for subtotals by category and grand total
- Flag any potential duplicates or missing information
### Claude Cowork for Competitive Intelligence: Research and Analysis Workflows
Ask Cowork to research competitors and it can:
- Analyze competitor websites, pricing pages, and feature lists
- Build a comparison matrix in Excel
- Identify gaps and opportunities
- Draft a memo with strategic recommendations
## Frequently Asked Questions
### How much does Claude Cowork cost?
Cowork requires a paid Claude subscription. Claude Pro ($20/month) gives you access to Cowork with standard usage limits. Claude Max ($100-200/month) provides significantly higher usage limits, worth it if you're running Cowork tasks daily. Team and Enterprise plans also include Cowork access. Note that Cowork tasks consume more usage allocation than regular chat because they involve multi-step agentic processing.
### Do you need to know how to code to use Cowork?
No. Cowork is specifically designed for knowledge workers who aren't developers. You interact with it in plain English, describe what you want done, and Claude handles the execution. Creating context files and skills requires writing Markdown (simple formatted text), but no programming knowledge. If you can write a Google Doc, you can configure Cowork.
### What's the difference between Cowork and Claude Code?
Claude Code is built for software development, it reads codebases, writes code, runs tests, and manages git repositories. It runs in the terminal and requires technical knowledge. Cowork is built for knowledge work, it manages files, creates documents, runs research, and automates business workflows. It runs in the Desktop app and requires no technical background. Same Claude brain, different interfaces for different jobs.
### Does Cowork remember previous sessions?
No, each Cowork session starts completely fresh. Claude doesn't retain any memory of previous conversations or tasks. This is why context files are so important: they provide the continuity that session memory doesn't. Good context files in your project folders mean Claude can produce consistent, high-quality output every time, even without remembering past sessions.
### Is my data safe with Cowork?
Cowork runs inside an isolated virtual machine on your computer. Your files stay local, they're not uploaded to Anthropic's servers for training. Claude asks for explicit permission before accessing folders, and requests approval before deleting any files. Conversation history is stored locally on your machine. That said, Cowork is still a "research preview," so Anthropic recommends against using it for regulated workloads. For sensitive industries, consult your compliance team before adoption.
### What platforms does Cowork support?
Cowork runs on macOS and Windows x64 via the Claude Desktop app. ARM-based Windows machines are not yet supported. There's no web, mobile, or Linux version, desktop only. Your computer must stay awake and the app must stay open for tasks to run.
### Why does Cowork use so much of my usage allocation?
Cowork tasks are compute-intensive because Claude is running multi-step agentic workflows, planning, executing subtasks, reading files, browsing the web, and coordinating outputs. A single Cowork task might involve dozens of internal steps. To manage usage: batch related work into single sessions, use standard Chat mode for simple questions, and monitor your usage in Settings > Usage. If you're hitting limits regularly, consider upgrading to Claude Max.
### How do I connect Cowork to my tools?
Go to Settings > Connectors > Browse connectors in Claude Desktop. Select the tool you want to connect (Slack, Notion, Salesforce, etc.) and follow the OAuth authentication flow. Once connected, Claude can access that service during any Cowork task. On Team and Enterprise plans, your admin may need to approve connectors before they're available. See the MCP tools section for more on how connectors work under the hood.
### Can I run Cowork tasks when my computer is off?
No. Cowork runs locally on your machine, so it requires your computer to be awake and the Claude Desktop app to be open. Scheduled tasks won't execute if your machine is sleeping or shut down. If you need always-on automation that runs 24/7, you'll need a cloud-based solution, a persistent AI server like Duet can run scheduled tasks, respond to webhooks, and process data around the clock without depending on your laptop.
### Can Cowork create Excel files with real formulas?
Yes. Unlike asking Claude in chat to "create a spreadsheet" (which gives you a text description), Cowork generates actual .xlsx files with working formulas, formatting, multiple sheets, and charts. It can also read existing Excel files, modify them, and create PowerPoint presentations. The Excel/PowerPoint integration is in research preview for Mac users on Max, Team, and Enterprise plans.
## Keep Reading
- Claude Code vs Claude Cowork: detailed side-by-side comparison.
- Claude Code for Business: the developer-focused counterpart to Cowork.
- How to Automate Content Creation: practical content workflows for solo operators.
- How to Use AI as a Personal Research Assistant: research workflows that work in both Cowork and Code.
---
Source: https://duet.so/guides/claude-opus-vs-sonnet-model-routing
# The $47,000 Claude Code Bill (and How Smart Model Routing Prevents It)
*Developers have burned $47K in days on Claude Code. Learn model routing with Opus, Sonnet, and Haiku to cut your AI bill by 50-70%.*
By Duet Team. Published 2026-05-29. 12 min read.
## The bill shock is real
A developer ran 23 subagents on a code-quality project. Three days later, the bill hit [$47,000](https://www.verdent.ai/guides/claude-code-pricing-2026). Not a typo. Forty-seven thousand dollars on AI-generated code reviews.
That's the extreme end. But the pattern is everywhere. A [49-subagent typescript-checks run](https://www.verdent.ai/guides/claude-code-pricing-2026) clocked $8,000 to $15,000. Someone left Claude Code running overnight with a looping script and [woke up to $6,000 gone](https://www.makeuseof.com/someone-left-claude-code-running-overnight-and-it-cost-6000/). One developer [burned through $15,000 in eight months](https://buildtolaunch.substack.com/p/claude-code-token-optimization) on API billing. That same usage would have cost $800 on a Max subscription.
Then there's enterprise scale. [Uber burned through its entire 2026 AI coding budget in four months](https://fortune.com/2026/05/26/uber-coo-ai-spending-tokens-claude-code/). Per-engineer bills ranged from $150 to $2,000 a month. Their COO called it a "head-exploding moment." Microsoft responded by canceling most of its Claude Code licenses entirely.
The common thread in every one of these stories? People running the most expensive model for every task. Opus for commit messages. Opus for formatting. Opus for boilerplate CRUD that Haiku could handle in its sleep.
You don't need to stop using Claude Code. You need to stop using the wrong model.
## Three models, three price points, three jobs
Claude comes in three tiers. Each one exists for a reason.
### Haiku: the fast, cheap workhorse
$0.25 per million input tokens. $1.25 per million output tokens. That's 60x cheaper than Opus.
Haiku is built for speed and volume. It handles simple, well-defined tasks where reasoning depth doesn't matter. Commit messages, boilerplate generation, formatting, string manipulation, quick Q&A about your codebase. The kind of work that makes up a surprising chunk of every coding session.
Most developers never even try Haiku for these tasks. They should.
### Sonnet: the daily driver
$3 per million input tokens. $15 per million output tokens. Five times cheaper than Opus, and the quality gap is smaller than most people think.
Sonnet handles 70 to 80 percent of typical development work at near-Opus quality. Landing pages, API routes, test writing, refactoring, content writing, standard code review. If the task has a clear goal and doesn't require multi-step architectural reasoning, Sonnet gets it done.
This is the model you should be using by default. Not Opus.
### Opus: the heavy hitter
$15 per million input tokens. $75 per million output tokens. The most capable and the most expensive.
Opus earns its price on tasks where getting it wrong costs more than the tokens. Architecture design, debugging subtle multi-file issues, complex database migrations, security audits, framework upgrades. Tasks that require deep reasoning across long context windows.
The mistake isn't using Opus. The mistake is using Opus for everything.
## The model-task matrix
Here's the cheat sheet. Every common task mapped to the right model.
For each task below, **Best** means it's the right model for the job. **Good** means it works but you're overpaying. **Overkill** means you're lighting money on fire.
### Simple tasks (use Haiku)
| Task | Haiku ($0.25/$1.25) | Sonnet ($3/$15) | Opus ($15/$75) |
| ------------------ | ------------------- | ----------------- | --------------------- |
| Commit messages | **Best** (~$0.01) | Overkill (~$0.12) | Way overkill (~$0.60) |
| Formatting/linting | **Best** | Overkill | Way overkill |
| Boilerplate/CRUD | Good | **Best** | Overkill |
| Simple Q&A | **Best** | Overkill | Way overkill |
| Regex/string ops | **Best** | Good | Overkill |
### Standard tasks (use Sonnet)
| Task | Haiku | Sonnet ($3/$15) | Opus ($15/$75) |
| -------------------------- | ----- | ------------------------ | ------------------------------ |
| Landing pages/UI | Weak | **Best** (~$0.15-0.50) | Good but 5x cost |
| Blog/content writing | Weak | **Best** | Good for complex long-form |
| Test writing | Weak | **Best** | Good for integration suites |
| Feature development | Weak | **Best** (most features) | Best for multi-system features |
| Code review (standard PRs) | Weak | **Best** | Overkill |
| Bug fixes (clear repro) | Weak | **Best** | Overkill |
| Refactoring | Weak | **Best** (targeted) | Best for large-scale refactors |
### Complex tasks (use Opus)
| Task | Haiku | Sonnet | Opus ($15/$75) |
| --------------------------------- | ----- | ------------------ | -------------- |
| Architecture design | No | Risky | **Best** |
| Multi-file debugging | No | Struggles | **Best** |
| Database migrations | No | OK for simple | **Best** |
| Security audits | No | Misses subtleties | **Best** |
| Complex reasoning (100K+ context) | No | Degrades | **Best** |
| Framework upgrades | No | OK for minor bumps | **Best** |
The pattern is clear. Most tasks fall in the simple or standard category. That means most of your token spend should be on Haiku and Sonnet, not Opus.
## How to save money, from beginner to pro
Not everyone wants to build a model router. Here's every method, graded by technical skill required. Start at your level and work up.
### Level 1: No code required
These work for anyone, even if you've never opened a terminal.
- **Switch to Claude Max** ($100/month) instead of API billing. One developer spending $15,000 over 8 months on API billing would have paid $800 on Max. That's a 93% savings.
- **Use /compact and /clear** to manage your context window. Tokens equal money. A bloated context window means every message costs more.
- **Start new sessions for new tasks.** Don't cram everything into one massive conversation. Fresh sessions reset context and reduce per-message token counts.
- **Run /cost** to check your spend in real-time. You can't optimize what you don't measure.
- **Set spending limits** in your Anthropic dashboard. Put a ceiling on monthly API spend so surprise bills literally can't happen.
These five steps alone will cut most developers' bills by 50% or more. If you do nothing else, do these.
### Level 2: Some config, no scripting
You know your way around a config file. You've edited `settings.json` before.
- **Use the --model flag** to manually select cheaper models. Run `claude --model claude-haiku-4` for simple tasks.
- **Write a CLAUDE.md** that sets Sonnet as default: "Use Sonnet for all tasks. Only escalate to Opus when the task involves architecture, complex debugging, or security analysis."
- **Limit subagent parallelism** in CLAUDE.md. "Never spawn more than 3 subagents at once." This is how $47,000 bills happen. Each subagent carries its own context window.
- **Use project-scoped settings** to enforce model defaults per repo. Different repos have different complexity profiles.
- **Cache frequently-used context** via the Project space. Stop re-uploading the same files every session.
- **Set per-session token budgets.** Know your ceiling before you start.
### Level 3: Shell scripts and hooks
You're comfortable writing bash scripts and configuring development tools.
- **Build a shell wrapper** that routes to different models based on task keywords or file types. "refactor" or "test" goes to Sonnet, "architecture" or "security" goes to Opus, everything else goes to Haiku.
- **Create a PostToolUse hook** that tracks token usage per session and alerts when thresholds are hit. Same concept as an audit trail hook, but focused on cost.
- **Use Haiku as a complexity classifier.** Feed it the task description, get back "simple/standard/complex", route to the corresponding model. Cost: fractions of a cent per classification.
- **Build a cost-tracking hook** that logs every API call: model, tokens in, tokens out, estimated dollar cost. Store it in a daily log file.
- **Generate weekly cost reports** from your logs. Know exactly where your money goes: by project, by task type, by model.
### Level 4: Full model router (or just use Duet)
You want automated, intelligent routing with zero manual intervention.
- **Build a complete model routing system:** request classifier, complexity scorer, model selector, execution layer, cost tracker. The classifier uses Haiku (pennies per call) to analyze task complexity, then routes to the right model.
- **Add rule-based fallbacks** for speed: file type detection, git diff size, keyword patterns. These bypass the classifier for obvious cases.
- **A/B test model selection.** Run the same tasks on Sonnet vs Opus, measure quality. You'll find Sonnet wins more often than you'd expect.
- **Build a cost dashboard** showing per-task, per-model, and per-project breakdowns.
- **Or skip all of this and use Duet.** Duet routes tasks to the right model automatically, tracks cost per agent, and handles the entire optimization pipeline. No config, no scripts, no maintenance.
## Before and after: real cost scenarios
Let's make the savings tangible.
### Scenario 1: Full-stack feature (landing page + API + tests)
**All-Opus approach:** 2 million tokens across planning, implementation, and testing. Cost: roughly $120 to $160.
**Routed approach:** Planning on Opus (300K tokens, ~$25). Implementation on Sonnet (1.2M tokens, ~$22). Boilerplate and test scaffolds on Haiku (500K tokens, ~$0.75). **Total: roughly $48. Savings: 65-70%.**
### Scenario 2: Content production (10 blog posts)
**All-Opus approach:** 5 million tokens. Cost: roughly $350 to $450.
**Routed approach:** All writing on Sonnet (4.5M tokens, ~$72). Formatting and metadata on Haiku (500K tokens, ~$0.75). **Total: roughly $73. Savings: 80%+.**
### Scenario 3: Code review sprint (20 PRs)
**All-Opus approach:** 3 million tokens. Cost: roughly $200 to $250.
**Routed approach:** Standard PRs on Sonnet (2.4M tokens, ~$40). Complex architectural PRs on Opus (600K tokens, ~$50). **Total: roughly $90. Savings: 55-65%.**
In every scenario, quality stays the same on the tasks that matter. You're not cutting corners. You're cutting waste.
## Why Duet handles this for you
Building a model router works. We just showed you how. But building it is one thing. Maintaining it across model updates, pricing changes, new model releases, and evolving team workflows is another.
Duet has model routing built in. Every task gets analyzed in real-time. Simple tasks go to faster, cheaper models. Complex tasks get escalated to Opus when the stakes justify it. No configuration. No classifier to train. No cost-tracking scripts to maintain.
- **Automatic complexity scoring** on every task
- **Real-time routing** to the optimal model
- **Built-in cost tracking** per agent, per task, per project
- **Teams don't need to think about model selection.** The system handles it.
If you'd rather ship than build infrastructure, Duet handles model routing out of the box.
## Frequently Asked Questions
No. For 70 to 80 percent of typical development tasks, Sonnet produces equivalent results. Opus
shines on complex reasoning and multi-step tasks. For everything else, you're paying 5x more for
the same output.
50 to 70 percent on typical development workflows. Content-heavy workflows can see 80%+ savings.
The exact number depends on your task mix, but the pattern holds across every scenario we've
tested.
Not if you route correctly. Each model gets full context for its task. The key is matching
complexity to capability, not using the same model for everything out of habit.
Yes. Use the --model flag to specify per-session, or build a wrapper script that routes based on
task type. Level 3 in our skill breakdown covers this in detail.
Extended thinking uses more tokens but produces better results on complex tasks. The routing
principle still applies: route extended thinking tasks to Opus, use standard mode for Sonnet and
Haiku tasks. Don't enable extended thinking on simple tasks.
For simple tasks like formatting, boilerplate, commit messages, and quick completions, yes. For
anything requiring reasoning about code logic or multi-step problem solving, use Sonnet or Opus.
Duet's router has been tuned on thousands of real tasks and updates automatically with new
models and pricing. Building your own works but requires ongoing maintenance, classifier tuning,
and keeping up with Anthropic's model releases. Duet handles all of that automatically.
---
Source: https://duet.so/guides/client-emails-renewal-follow-ups-faster-with-ai
# Client Emails and Renewal Follow-Ups Faster with AI
*Speed up client emails and renewal follow-ups with an AI drafting system that keeps communication consistent.*
By Duet Team. Published 2026-03-06, updated 2026-04-19. 8 min read.
# How to Write Client Emails and Renewal Follow-Ups Faster with AI
Quick Summary
This guide shows insurance agents how to use AI to write client emails and renewal follow-ups faster. With templates, personalization frameworks, and automation workflows that maintain the personal touch clients expect.
Questions this page answers
- How to write insurance client emails faster with AI
- Best AI tools for insurance agent email writing
- How to automate renewal follow-ups with AI
- AI email templates for insurance agents
- Can AI write personalized insurance follow-up emails?
## How can AI speed up client renewal emails?
AI speeds up client renewal emails by analyzing expiring policy data, identifying coverage gaps, and automatically generating personalized follow-up drafts. This reduces the time agents spend reviewing files from hours to seconds, ensuring clients receive timely, accurate renewal notices before their expiration dates.
Client communication is where time disappears quietly. Not because any one email is hard, but because the work never arrives in a clean batch.
It shows up all day, in bursts: a renewal coming up, a carrier asking for something, a client who went cold after a quote, a dec page you still need.
The goal is not to send more emails. It is to send the right ones faster, with less effort, and with fewer things falling through the cracks.
## Hidden Cost of Slow Client Communication in Insurance Agencies
In most agencies, the problem is not that people do not care about communication. It is that every message has to be written, checked, and sent from scratch while the rest of the day is already full.
That creates a slow, expensive kind of drag:
- Follow-ups go out later than they should
- Tone and quality vary from one team member to another
- Important details get missed or left out
- Renewal conversations start later and lose momentum
Over time, that affects more than efficiency. It affects responsiveness, client confidence, and the consistency people feel when they interact with your agency.
## How to Build an AI Communication System for Your Insurance Agency
You do not need to generate every client email from scratch, and you do not need a complicated automation stack to improve this.
What works is a simple drafting system your team can use consistently.
### Set Up Reusable Message Types, Not One-Off AI Prompts
Start by defining the communication types your agency sends over and over again:
- Renewal reminders
- Missing information follow-ups
- Quote status updates
- Simple policy explanations
- Post-call recap emails
The goal is to stop reinventing the structure every time a message needs to go out. Related reading: How to Use AI to Write Sales Emails That Get Replies covers similar templating patterns for outbound.
### Add a Short Account Context Block to Every AI Email Request
Before drafting, give the system a small amount of context so the message reflects the actual situation.
That context might include:
- Client type
- Line of business
- Stage in the policy or renewal process
- Priority concern or recent issue
- Desired next step
This keeps the message grounded in the account instead of sounding generic. If the context involves data you are already structuring for quoting, the rekeying workflow can feed directly into these drafts.
### Draft Multiple Versions and Pick the Best One
For recurring client communication, it helps to generate two versions:
- Version A: Short, direct, and action-oriented
- Version B: Warmer, more explanatory, and slightly more consultative
That gives the sender a fast choice based on the client, the situation, and the tone the moment calls for.
### Always Run a Human Review Before Sending AI-Drafted Client Emails
Before any draft goes out, do a quick final pass:
- Remove unnecessary identifiers
- Confirm policy facts and dates
- Verify deadlines, requested actions, and next steps
- Make sure the message reflects what the agency is actually advising or asking
The point is not to automate judgment. It is to reduce writing time while keeping accuracy and
consistency high.
## AI Prompt Starter
Client Emails and Renewal Follow-Ups
> Draft two renewal follow-up emails for this client context. Version A should be concise. Version B should be advisory. Include clear next steps and deadline language.
## Where Insurance Agencies Go Wrong With AI Email Automation
Agencies do not struggle because they lack tools. They struggle because the basics are not standardized.
The common failure points are predictable:
1. No shared voice or tone rules. Different people write different kinds of emails, so the client experience feels inconsistent.
1. Drafts created without account context. Messages come out generic because the sender did not include the policy stage, client situation, or the specific next step.
1. No pre-send checklist. Dates, deadlines, and factual details are the easiest things to get wrong and the hardest things to explain after the fact.
1. No measurable response standard. If there is no internal expectation for how quickly renewals and follow-ups should be handled, "urgent" becomes subjective and important messages slip.
Fix those four first. Once the fundamentals are consistent, adding automation actually helps instead of creating more noise.
## A 60/30/14-Day Renewal Cadence That Actually Ships
The single highest-leverage change most agencies make with AI is not writing better emails. It is sending the right emails on time.
A simple three-touch renewal cadence works for most personal and small commercial books:
- **60 days out** — proactive outreach that previews what to expect. Flag any known coverage gaps, rate changes, or questions you want to ask before marketing. The AI drafts this from the account packet in under a minute.
- **30 days out** — the options email. Share the renewal quote plus any alternative markets you remarketed. Keep it scannable: current premium, renewal premium, delta, coverage differences, and a clear next step.
- **14 days out** — the decision nudge. Short, specific, and dated. If the client has not responded, the AI writes a warmer re-engagement version that references the prior thread instead of starting over.
Run the cadence the same way every time. Let AI handle the drafting so your team is spending its energy on judgment calls — which accounts need a phone call, which need a meeting, which can close over email — instead of reassembling the same facts from three different systems.
## Metrics to Track When Using AI for Client Communications
Keep this simple. You want a few indicators that tell you whether communication is getting faster and more consistent.
| Metric | What It Measures |
| --------------------------------- | ----------------------------------------------------------------------------------------- |
| Time-to-first-response | How long it takes to respond to a client email, text, or portal message |
| Renewal follow-up completion rate | Percentage of renewals that receive the planned outreach sequence (60/30/14-day touches) |
| Client reply time | How long clients take to respond once you send a follow-up |
| Renewal conversion by segment | Renewal rate split by segment so you can see where improved communication moves retention |
If those numbers improve, the system is working.
---
## Frequently Asked Questions
### How can AI help insurance agents write client emails faster?
AI can draft personalised client emails in seconds based on a brief prompt - renewal reminders, coverage change confirmations, claim follow-ups, and new business outreach. Instead of writing each email from scratch, you describe the situation and the AI produces a professional draft you review and send.
### What information should I give AI to write a good renewal follow-up email?
The more context the better: the client's name, policy type, renewal date, any coverage changes, whether it's a standard renewal or there are rate increases, and your desired tone. The AI will produce a more accurate draft with specific details than with generic instructions.
### Is it ethical to use AI for client communications in insurance?
Yes - as long as a licensed professional reviews and approves communications before sending. AI handles the writing and formatting; the agent provides the professional judgment and takes responsibility for what is sent.
### Can AI automatically send renewal follow-ups on a schedule?
Yes, with the right setup. An AI agent connected to your agency management system can identify upcoming renewals, generate follow-up emails, and send them automatically - or queue them for your review. Platforms like Duet can run this as a background agent that works through your renewal list daily.
### How do I make AI-generated emails sound like me?
Train the AI on your communication style by providing examples of your past emails. Most AI tools let you add style instructions that shape the output. After a few rounds of editing, the drafts will require minimal changes to match your voice.
### What is the risk of using AI for client emails?
The main risk is sending inaccurate information - policy details or dates that are wrong because the AI received incomplete input. The mitigation is a mandatory human review step before sending any client communication. Never set up fully automated sending without a review checkpoint for coverage-related content.
---
Source: https://duet.so/guides/duet-ai-for-founders
# Duet AI for Founders: Founder Mode as an Operating System
*Duet AI turns Founder Mode into an operating system. Run a 3-person company like a 50-person one. Ship faster. Skip middle management. Stay close to the product.*
By Duet Team. Published 2026-04-17, updated 2026-04-17. 19 min read.
Founder Mode used to be a personality trait. With Duet AI, it's an operating system.
Paul Graham coined the term in September 2024 after Brian Chesky told a room of YC founders that the standard advice, "hire good people and give them room to do their job," nearly killed Airbnb. The fix was not hiring better managers. It was running Airbnb the way Steve Jobs ran Apple: skip-level access, relentless detail obsession, zero layers between the founder and the product.
The thing nobody said at the time: Founder Mode had a physical ceiling. One human cannot sit in 40 code reviews, 12 customer calls, and 8 design crits a week. At some point every founder hires a VP, then a director, then a manager for the managers. The bloat layer begins and velocity dies.
Agents break the ceiling.
This guide shows you how to run Founder Mode as a system, not a vibe. You'll learn the playbook stack, the durable context, the daily cadence, and the exact prompts to paste into Duet this week.
**Quick Summary**
Duet AI is an AI agent workspace that turns Founder Mode into an operating system. You stay hands-on with product, team, and details at any scale by replacing middle management with specialized agents. You assign outcomes, the agents execute in parallel, and you stay in the review loop. Small teams out-ship 50-person companies because the bottleneck becomes founder judgment, not headcount.
---
## What is Founder Mode?
**Founder Mode** is a way of running a company where the founder stays hands-on with the product,
the team, and the details, no matter how big the company gets. Coined by Paul Graham in September
2024 after a talk by Airbnb CEO Brian Chesky at a Y Combinator event.
A few things define Founder Mode in practice:
- **Skip-level everything.** Founders talk to ICs directly. No pre-meetings, no filtered updates, no org-chart theatrics.
- **Small, direct teams.** Steve Jobs ran annual retreats with the 100 most important people at Apple, regardless of where they sat on the org chart. Impact was the filter. Seniority was not.
- **Detail obsession.** Founders stay in the code reviews, the copy edits, the customer calls, the pricing math.
- **No modular delegation.** Manager Mode treats every team as a sealed subtree and hopes for the best. Founder Mode opens the boxes whenever the founder wants.
Founder Mode is not micromanagement. It is the refusal to pretend that distance from the product makes you a better leader.
---
## Why Manager Mode fails
Every founder has lived this story.
You start with a team of three. You ship features on Tuesday and close paying customers on Friday. Growth is good, so you raise a Series A. You hire a VP of Product because someone told you that's what grown-up companies do. Six months later, shipping a feature takes three months, and you can't remember the last time you talked to a real user.
That is Manager Mode.
The people architecting the product are not the people coding it. Product managers schedule pre-meetings for the sync meetings. The company optimizes for internal politics instead of customer velocity. Vision drifts because no one in the execution chain has the founder's full context.
Garry Tan, CEO of Y Combinator, has been one of the loudest voices against this default. His argument: hiring a layer of professional managers almost always introduces bloat, slows shipping, and puts the founder on the wrong side of the product. The best founders do not graduate out of the trenches. They buy better shovels.
### Founder Mode vs Manager Mode
| | **Manager Mode** | **Founder Mode** |
| ---------------------------- | --------------------- | ------------------------ |
| **Who talks to ICs** | VPs and directors | The founder |
| **Delegation style** | Sealed subtrees | Opened whenever needed |
| **Feedback loop** | Quarterly reviews | Daily PR comments |
| **Decision speed** | Alignment meetings | Fast, high-context calls |
| **Default fix for problems** | Hire a manager | Ship a patch |
| **What scales** | Headcount | Output |
| **Bottleneck** | Coordination overhead | Founder judgment |
---
## Why agents break the Founder Mode ceiling
The reason Founder Mode had a ceiling was physics. One founder cannot sit in 40 code reviews, 12 customer calls, and 8 design crits a week without burning out. So at some point, most founders hire a COO, a VP, a director, and the bloat layer begins.
AI agents kill the physics problem.
An agent can sit in the code review. An agent can draft the design spec. An agent can write the cold email sequence, read the customer interview transcript, and flag the churn pattern. Each one runs in parallel. Each one takes your full context as input. None of them ask for a performance review or a Notion page about "team ceremonies."
The goal is no longer to scale headcount. It is to scale output.
This is what Duet enables: the founder stays the primary orchestrator, and a fleet of specialized agents handles execution. Velocity stops being a function of how many humans you hired last quarter and starts being a function of how sharp your playbooks, durable context, and briefs are.
---
## The Founder Mode stack in Duet
A chat window is not Founder Mode. Asking vague questions in a text box is the AI equivalent of hiring a junior generalist. You re-explain context, re-review bad output, and slowly drift back toward Manager Mode because the agent cannot finish anything.
Three layers change the equation.
### 1. Memory repos: institutional knowledge that never quits
A normal hire takes six weeks to get up to speed. They read docs, shadow calls, fumble through the codebase, and ask the same questions twice. A memory repo removes that step entirely.
Files and Train give your agents durable context they can draw on across Sessions:
- Architectural decisions and the reasons behind them
- Brand voice, tone guidelines, banned words
- Past customer complaints and how you resolved them
- The pricing experiment you killed in March and why
- The positioning narrative you approved last quarter
Memory is not documentation. Documentation is for humans who might read it. Memory is the substrate your agents run on every single session.
### 2. Playbook files: specialist methods on the bench
The wider agent ecosystem calls reusable instruction bundles “skills.” In Duet, there is no catalog or install step: keep the parts you adopt as ordinary playbook files in Files, then point the agent at the relevant instructions in a Session. A strong playbook captures the opinions, frameworks, and quality bar you would expect from a specialist.
You are not teaching the agent how to design, write, or sell. You are pointing it at the problem.
For the full mental model, see our deep-dive on [Agent Skills 101: Tools vs MCP vs Skills](/guides/agent-skills-101-tools-vs-mcp-vs-skills).
### 3. Orchestration: you, staying in the review loop
You are the taste filter. Not the task assigner. Your job in Founder Mode with Duet:
- Write sharp briefs with outcomes, not step lists
- Review PRs, drafts, and designs against taste, not grammar
- Send work back with a one-line correction and a pointer to memory
- Update the brief or the memory when the output drifts, not the one-off prompt
The agent handles the execution loop. You handle the judgment loop. That trade is the entire Founder Mode unlock.
---
## Real repos and skills to adapt this week
You do not need to build this stack from scratch. The ecosystem already shipped the pieces.
### Official Anthropic repositories
- **[anthropics/skills](https://github.com/anthropics/skills)**. Anthropic's official skills repo. It includes starter material for document generation, data analysis, research, and creative work. Review the instructions you need and keep the adapted playbooks in Duet Files.
- **[anthropics/knowledge-work-plugins](https://github.com/anthropics/knowledge-work-plugins)**. Pre-built plugins for sales, marketing, finance, and general productivity. Drop-in quality for non-engineering roles.
### Duet team's own stacks
- **[anianroid/claude-code-starter-pack](https://github.com/anianroid/claude-code-starter-pack)**. The full starter pack we use internally. Skills, CLAUDE.md templates, MCP configs, and the patterns that actually stick.
- **[Sawyer-Middeleer/cc-gtm](https://github.com/Sawyer-Middeleer/cc-gtm)**. Our GTM skill pack: market research, contact enrichment, copywriting in your voice, CRM cleanup. Every skill from the [Claude Code for Founders guide](/guides/claude-code-for-founders) lives here.
### Community power packs (steal these today)
- **[garrytan/gstack](https://github.com/garrytan/gstack)**. Garry Tan's opinionated Claude Code setup. 23 slash-command specialists (CEO review, eng review, design review, ship, QA) that turn one agent into a virtual engineering team. 20k+ stars. The closest open-source analog to running Founder Mode.
- **[garrytan/gbrain](https://github.com/garrytan/gbrain)**. Garry Tan's open-source AI knowledge system. Long-term memory for agents, stored as markdown in a git repo. People, companies, meetings, transcripts, ideas. Agents scan and enrich it while you sleep. Exactly the memory repo layer above.
- **[obra/superpowers](https://github.com/obra/superpowers)**. Jesse Vincent's agentic skills framework. Composable skills for TDD, systematic debugging, brainstorming, and subagent-driven development. 355k+ installs. Enforces red-green-refactor and root-cause debugging before any fix.
- **[blader/humanizer](https://github.com/blader/humanizer)**. Claude skill that strips AI-generated tells from writing. Based on Wikipedia's "Signs of AI writing" guide. Use its review method as a second-pass playbook before any draft leaves the building.
- **[nextlevelbuilder/ui-ux-pro-max-skill](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill)**. Design intelligence skill. 50+ styles, 161 color palettes, 99 UX guidelines, 10 stack targets (React, Next, Svelte, SwiftUI, Flutter, etc.). Activates automatically on any UI/UX brief. Closest thing to a senior designer on the bench.
- **[gsd-build/get-shit-done](https://github.com/gsd-build/get-shit-done)**. Spec-driven meta-prompting system by TÂCHES. Spawns fresh subagent contexts for each task so long sessions do not degrade. Built-in schema drift detection, security enforcement, TDD pipeline mode. The execution engine that keeps long-running workstreams from drifting.
- **[travisvn/awesome-claude-skills](https://github.com/travisvn/awesome-claude-skills)**. Curated discovery list of every serious Claude skill in the wild. Your feed for when the starter bench isn't enough.
### Watch and read (context on why this works)
- **[Garry Tan announcing gbrain on X](https://x.com/garrytan/status/2044945773541089321)**. The original "I might give it away as open source" thread. Context on what long-term agent memory looks like in production.
- **[Garry Tan launching gstack on LinkedIn](https://www.linkedin.com/posts/garrytan_gstack-use-garry-tans-exact-claude-code-activity-7438369912357806080-DpoI)**. The viral launch post that turned skill packs into a public category.
- **[TechCrunch: Why Garry Tan's Claude Code setup got so much love, and hate](https://techcrunch.com/2026/03/17/why-garry-tans-claude-code-setup-has-gotten-so-much-love-and-hate/)**. Read both sides before adopting.
- **[Jesse Vincent: How I'm using coding agents](https://blog.fsck.com/2025/10/09/superpowers/)**. The backstory behind Superpowers. Read it to understand why TDD-enforced agent workflows beat free-form prompting.
- **[Simon Willison's notes on Superpowers](https://simonwillison.net/2025/Oct/10/superpowers/)**. A second expert's read. Great for quick skim.
- **[SitePoint: GStack Tutorial for 10K LOC/Week](https://www.sitepoint.com/gstack-garry-tan-claude-code/)**. Guided install if you want more than the README.
### Your own stack
The real power comes from the playbooks you build around your product and your voice. Start with three:
1. **A context brief** that points to brand voice, positioning, and past decisions stored in Files and Train.
2. **A writing playbook** grounded in your best public writing (landing pages, posts, and essays). Every first draft should already sound like you.
3. **A review playbook** that runs your personal pre-ship checklist against PRs, drafts, and designs before you look at them.
For the full build pattern, see [How to Build a Shared AI Skill Library](/guides/beyond-claude-code-building-a-shared-skill-library).
---
## The 7-day Founder Mode sprint
Founder Mode as a system does not need a quarter. It needs a week.
### Day 1: Pick your bottleneck session
Open [duet.so](/) and create one session. Do not create seven. Pick the single function eating the most founder time right now. Design. Copy. Cold outreach. Customer research. Whatever makes you groan on Sunday night.
### Day 2: Add durable context
Add the source material to Files, and use Train for the durable facts and connected sources the agent should carry across Sessions:
- Your top 5 public writing samples (tweets, blog posts, landing page copy)
- Your positioning doc or a 200-word "what we sell and why" brief
- The last 3 customer calls as transcripts or notes
- Your 10 most important past decisions and the reasons behind them
This takes two hours. It pays back every session after.
### Day 3: Adapt one playbook
Pick one reusable instruction set from [anthropics/skills](https://github.com/anthropics/skills) or [cc-gtm](https://github.com/Sawyer-Middeleer/cc-gtm) that maps to the bottleneck. Adapt it into a clearly named file alongside the source material used by the Session. Start with one so you can see which instructions actually improve the result.
### Day 4: Run one real job end-to-end
Not a demo. Not a toy. A real piece of work with a real deadline. Brief the agent with an outcome, not a task list:
> "Ship a 3-email re-engagement sequence for users who signed up, created an account, and never came back. Length: 80 words each. Goal: get them to log back in this week. Voice: match the samples in memory. Ready to paste into [your ESP] by EOD."
Review the output. Redirect. Ship.
### Day 5: Tighten the brief, tighten the memory
Whatever went wrong, fix the root cause:
- If the tone drifted, add 3 more writing samples to memory
- If the CTA was weak, update the brief template with a CTA rubric
- If the agent hallucinated a feature, add the product spec to memory
Do not fix the one-off prompt. Fix the system.
### Day 6: Start a second session
Same pattern, different function. If Day 1 was design, Day 6 is growth. If Day 1 was writing, Day 6 is code review.
### Day 7: Run parallel
Run both sessions. Brief the agent with two independent outcomes and review both outputs. This is the first day you will feel the physics break.
By Day 8 you will stop asking whether agents can run execution. You will start asking how many concurrent sessions you can sanely orchestrate.
---
## The daily Founder Mode operating cadence
Cadence is where Founder Mode either becomes an operating system or dies as a good intention.
### Morning: 30-minute review block
Open Duet. Skim the active sessions. You are looking for three things:
- What shipped overnight that needs your taste filter
- What is stuck waiting on a founder decision
- What the agents flagged that you would have missed
Respond in-line. Ship the good stuff. Send the bad stuff back with one-sentence corrections.
### Midday: outcome-based briefs
Write 2-3 new briefs for the afternoon. Each one names an outcome, acceptance criteria, and the relevant playbooks. Skip anything that does not need you to write the brief yourself.
### Afternoon: parallel execution (you are not in this loop)
The agents work. You do the thing only you can do: talk to a customer, close a deal, make the strategic call, or delete a feature.
### Evening: ship and curate memory
30 minutes at end of day. Ship what's ready. Then curate memory:
- One positive example into the "good output" folder
- One correction into the "voice rules" file
- One decision into the "decision log"
Memory that does not get curated decays. Memory that gets curated compounds.
### Weekly: the Sunday sharpen
One hour every Sunday. Audit the week:
- Which briefs worked? Why?
- Which outputs missed? What did the context or playbook lack?
- Which Session is ready to hand off to the team?
- Which playbook is reliable enough to become the default?
This is the loop that turns Founder Mode from a vibe into a flywheel.
---
## Founder Mode prompts to paste in Duet
Steal these. Adapt the bracketed pieces.
### The outcome brief
```
Outcome: [final state, one sentence]
Success metric: [measurable thing, numeric if possible]
Playbooks to follow: [list the relevant instruction files]
Context to use: [brand voice, last 3 customer calls, positioning doc]
Constraints: [length, tone, banned words, deadlines]
Out of scope: [what NOT to do]
First deliverable: [what I want to see in my next review]
```
### The review-and-redirect
```
Good: [what worked, 1 line]
Drifted: [what missed, 1 line]
Fix: [specific correction, 1 line]
Update memory: [the rule or sample to add so this never happens again]
Ship when: [new acceptance criteria]
```
### The memory curation prompt
```
Read the last 5 shipped deliverables from this workstream.
Extract: voice patterns that worked, phrases I repeated, CTAs that landed.
Update the voice memory file with a "confirmed patterns" section.
Flag: any pattern I used that contradicts the existing voice guidelines.
```
### The "fire the bloat layer" prompt
```
Audit my last 30 days of work in these Sessions.
List every decision that waited more than 24 hours for me.
For each: suggest a playbook change, Train update, or pre-approved rule that would let an agent handle it next time without founder involvement.
Flag the 3 highest-leverage changes.
```
---
## What good looks like: the 3-person company that out-ships the 50-person company
The era of building a management pyramid to scale a software company is ending. The companies winning now are not the ones that hire the fastest. They are the ones that stay close to their product the longest.
A 3-person team running Founder Mode in Duet can out-ship a 50-person org if:
- Memory is curated weekly
- Playbooks are specific, not generic
- Briefs are written as outcomes, not tasks
- Founders review, and never become the assignment desk
- Every human hire replaces an agent that hit a ceiling, not an agent that worked
Founder Mode used to be a personality. With Duet, it is an operating model. Load your bench. Keep your team small. Stay in the details. Ship at the speed you did on day one, at any size you want.
---
## FAQ
**What is Founder Mode?**
Founder Mode is a way of running a company where the founder stays deeply involved in the
product, the team, and the details at any scale. Paul Graham coined the term in September 2024
after a talk by Airbnb CEO Brian Chesky at a Y Combinator event. Chesky said the conventional
advice, "hire good people and give them room to do their job," nearly destroyed Airbnb. Running
it like Steve Jobs ran Apple fixed it.
**What is the difference between Founder Mode and Manager Mode?**
Manager Mode is the conventional playbook: hire professional managers, delegate through a
hierarchy, let subtrees of the org chart run as black boxes. Founder Mode rejects that. The
founder keeps skip-level access, stays hands-on with the product, and refuses to trade shipping
velocity for org chart neatness.
**How does Duet enable Founder Mode?**
Duet lets founders assign execution work directly to specialized AI agents instead of hiring a
middle management layer. Agents scale output without scaling headcount, so the founder stays in
the loop on everything that matters. Reusable playbooks, durable context, and parallel Sessions
replace the coordination overhead that makes Manager Mode necessary in the first place.
**Can I use agent skills with Duet?**
Yes, as source material rather than an installed Duet feature. Anthropic publishes reusable
instruction bundles at [github.com/anthropics/skills](https://github.com/anthropics/skills).
Review the bundle you need, adapt it to your company, and keep the resulting playbook in Files.
Duet does not have a skills catalog or an install flow.
**Why do memory repos matter for Founder Mode?**
A memory repo loads your company's history, brand voice, architectural choices, and past
decisions on every session. No onboarding, no context loss, no repeated mistakes. Agents pull
from it the way a senior hire pulls from instinct. Without memory, you re-onboard your agents
every morning and drift back into Manager Mode by Friday.
**Can a 3-person team really out-ship a 50-person startup?**
Yes, if the team runs the Founder Mode playbook. A 3-person team with sharp durable context, the
right playbooks, and disciplined review can ship faster than a 50-person org drowning in
coordination overhead. The bottleneck stops being headcount and starts being founder judgment,
which is the point.
**Isn't Founder Mode just micromanagement?**
No. Micromanagement is adding friction without adding signal. Founder Mode is staying close
enough to the product to keep taste, speed, and vision aligned. Done with agents instead of
people, it scales without the burnout and without the human friction that made micromanagement
toxic in the first place.
**How do I start running Founder Mode with Duet?**
Sign up at [duet.so](/). Pick your single biggest bottleneck function and create one Session.
Add your voice, positioning, and last 3 customer calls to Files and Train. Adapt one external
instruction set into a playbook file. Write an outcome-based brief, ship the output, and
iterate. The 7-day sprint in this guide is the step-by-step version.
**Does Founder Mode mean I should never hire?**
No. It means every human hire should replace an agent that hit a ceiling, not an agent that was
working. Hire for judgment, relationships, and domain expertise agents cannot fake. Do not hire
to solve coordination problems agents already solve.
---
## Keep reading
- [How to Build Your AI Command Center with Duet](/guides/how-to-build-your-ai-command-center). The full setup for your Duet workspace.
- [Claude Code for Founders](/guides/claude-code-for-founders). The GTM, product, and ops skill pack that started it all.
- [Agent Skills 101: Tools vs MCP vs Skills](/guides/agent-skills-101-tools-vs-mcp-vs-skills). The mental model for how skills actually work.
- [How to Build a Shared AI Skill Library](/guides/beyond-claude-code-building-a-shared-skill-library). Package tribal prompts into reusable team capability.
---
Source: https://duet.so/guides/duet-vs-claude-code
# Duet vs Claude Code: Cloud Agent vs CLI
*Compare Duet and Claude Code: solo CLI vs cloud dev environment with a persistent always-on agent.*
By David. Published 2026-02-23, updated 2026-05-08. 9 min read.
# Duet vs. Claude Code: Comparing Cloud Agents and Local CLI
Quick Summary
This comparison covers Duet vs Claude Code - a managed cloud agent platform vs a CLI-based local coding tool. Claude Code is powerful but session-based and single-player. Duet gives you Claude Code that's persistent, always-on, and multi-player for your whole team.
Questions this page answers
- What is the difference between Duet and Claude Code?
- Duet vs Claude Code: which is better?
- Is Duet just a cloud version of Claude Code?
- How does Duet compare to Claude Code for teams?
- What are the limitations of Claude Code vs Duet?
Claude Code is Anthropic's agentic coding and one of the most powerful developer tools ever built.
Duet runs Claude Code (and other agents) in the cloud with team context, persistent memory, and zero-configuration deployment.
They're complementary, but serve very different use cases.
---
## What is Claude Code? (And Why Teams Hit Its Limits)
Claude Code is Anthropic's terminal-first agentic coding tool. It reads your codebase, writes and edits files, runs commands, manages git workflows, and can loop for hours on complex tasks. It hit $1 billion in annualized revenue within six months of launch.
Key characteristics:
- CLI-first, also available in VS Code, JetBrains, and desktop app
- Reads entire codebases, plans multi-step implementations, executes autonomously
- Experimental multi-agent teams (Agent Teams) for parallel task execution
- Claude Agent SDK for building custom agents
- Runs locally on your machine during active sessions
## What is Duet?
A Cloud-Native Claude Code Alternative
Duet is a cloud dev environment that gives every user and team a private cloud server with a persistent, always-on AI agent. Instead of a terminal session that dies when you close your laptop, Duet gives your agent its own server with persistent memory, 10,000+ integrations out of the box, built-in app hosting, scheduling, and a shared workspace where people assign work in durable sessions and inspect the resulting events and artifacts.
---
## Duet vs Claude Code: Full Feature Comparison (2026)
| | Duet | Claude Code |
| ---------------- | ------------------------------------------------------------------------ | ----------------------------------------------------------------------- |
| Where it runs | Managed cloud server (24/7) | Your local machine (session-based) |
| Persistence | Always-on with persistent memory across sessions | Stateless — every session starts from zero |
| Team support | Shared workspace, durable sessions, files, apps, and org-wide context | Single-user; no shared workspaces |
| Setup | One click | Install CLI, configure API keys, set up CLAUDE.md files |
| Scheduling | Built-in cron and event-driven automation | None — must be built externally |
| Models | Claude Opus, Sonnet, GPT-5, multi-model routing | Claude models only |
| Integrations | 10,000+ out of the box (managed connectors + MCP) | None built in — manual MCP server setup required |
| Non-coding tasks | Full-stack: email, research, GTM, ops, integrations | Code-focused (though Agent SDK enables broader use) |
| Usage limits | Monthly included credits plus a paid reserve for overage | Per-user limits that reset every 5 hours, shared across all Claude apps |
| Interface | Web workspace with Sessions, Apps, Files, Train, and Integrations | Terminal / IDE |
| Agent identity | Persistent identity with memory, personality, and organizational context | Session-scoped; identity resets each time |
---
## Where Claude Code Wins: Raw Coding Power
Raw coding power. Claude Code with Opus 4.6 is arguably the best AI coding tool available. It understands complex codebases, plans multi-file changes, handles git workflows, and can work autonomously for hours. The experimental Agent Teams feature can even run parallel Claude instances on different tasks.
Developer ergonomics. If you live in the terminal, Claude Code feels native. It integrates with VS Code, JetBrains, and the full git workflow. The CLAUDE.md configuration system is elegant.
Agent SDK. The Claude Agent SDK lets you build custom agents on top of Claude Code's infrastructure with proper context management, tool ecosystems, and session handling. It's a powerful foundation for developers building their own agent systems.
Ecosystem. @claude tagging in GitHub PRs, Chrome extension for browser control, and growing IDE support make Claude Code deeply integrated into the developer workflow.
## Where Duet Wins:
Teams, Persistence, and Beyond Code
Persistence and memory. This is Claude Code's most-requested missing feature. Every Claude Code session starts from zero no memory of previous sessions, no accumulated understanding. Community workarounds (CLAUDE.md files, --resume flags) are manual and imperfect. Duet's agent has persistent memory, personality, and organizational context that builds over time. See [Duet AI for Founders](/guides/duet-ai-for-founders) for the operator playbook that puts this persistence to use.
Always-on. Claude Code agents run only when invoked and die when your session ends. Duet's agent runs 24/7 on its own cloud server, running scheduled tasks and responding to events from connected systems. No laptop required.
Team collaboration. Claude Code is fundamentally single-user. Usage caps are per-user, not pooled. There's no way to share context or analysis across team members; each developer works in isolation. Duet gives a team shared sessions, files, apps, artifacts, and organizational context around the same persistent AI coworker.
10,000+ integrations out of the box. Claude Code has no built-in integrations connecting to external services means manually setting up MCP servers or writing custom tool code. Duet ships with 10,000+ managed integrations and MCP tools, so your agent can connect to Linear, Slack, Gmail, Google Calendar, GitHub, and thousands more without any setup.
Beyond coding. Claude Code is optimized for software engineering. Duet's agent handles the full stack email triage, GTM research, content creation, operations automation, scheduling, and more.
Multi-model routing. Claude Code only supports Claude models. Duet routes to the best model per task Claude Opus for complex reasoning, Sonnet for speed, GPT-5 for specific use cases.
Clear billing ownership. Claude Code's usage limits reset every 5 hours and are shared across its apps. Duet's monthly credits reset at renewal; a workspace owner designates an owner as payer, and that payer manages methods, reserve topups, limits, and history from user settings.
---
## Duet + Claude Code: Why They Work Better Together
Duet doesn't replace Claude Code it runs Claude Code (among other agents) in a team-first, always-on environment. Think of it this way:
- Claude Code = the engine (powerful single-developer coding AI)
- Duet = the vehicle (managed cloud platform that runs the engine 24/7 with team context)
Many Duet users also use Claude Code locally for hands-on coding sessions. The difference is that Duet's agent is always available, remembers everything, and works across the whole team — not just in one developer's terminal.
---
## Who Should Choose Claude Code vs Duet?
Choose Claude Code (standalone) if:
- You're a solo developer who wants a powerful terminal-based coding assistant
- Your work is primarily code you don't need email, GTM, ops, or scheduling
- You're comfortable with session-based workflows and manual context management
- You prefer local execution and direct control
Choose Duet if:
- You're a team that needs shared AI context and collaborative workflows
- You want an always-on agent that works while you sleep
- You need more than coding email, research, operations, integrations
- You want persistent memory that builds organizational knowledge over time
- You want Claude Code's power without managing infrastructure
---
## The Verdict: Claude Code vs Duet for Teams in 2026
Claude Code is an incredible developer tool. But it's a solo tool session-based, code-focused, and stateless. Duet takes the same underlying power and wraps it in team context, persistent memory, always-on cloud infrastructure, and multi-domain capabilities.
If you're one developer writing code, Claude Code is great. If you're a team running AI agents across your whole operation, Duet is what you need.
Ready to try Duet? Deploy your agent in one click →
---
## Frequently Asked Questions
### What is the main difference between Duet and Claude Code?
Claude Code is a CLI tool that runs on your local machine for coding tasks, stopping when you close your session. Duet is a cloud platform where AI agents run persistently 24/7 without requiring your laptop to be open. Claude Code is a developer tool; Duet is a team automation platform.
### Can Duet run Claude Code in the cloud?
Duet runs Claude-powered agents in the cloud that do many of the same things Claude Code does - code generation, task execution, file operations. It uses Claude's API with its own agent infrastructure, scheduling, and team features. It serves many of the same use cases in a cloud-native way.
### Who should use Claude Code vs Duet?
Claude Code is best for individual developers who want tight integration with their local dev environment and are working on coding tasks that don't need to run continuously. Duet is better for teams that need agents on schedules, shared workspaces, and automation workflows beyond coding.
### Is Claude Code free compared to Duet?
Claude Code requires an Anthropic API subscription and uses tokens per session. Duet includes cloud infrastructure and team features on top of API costs. For light individual use, Claude Code may be cheaper. For teams running agents continuously, Duet's bundled pricing often makes more sense.
### Can you use Claude Code and Duet together?
Yes - many teams use Claude Code for local development work and Duet for deploying automated workflows to the cloud. Claude Code for interactive coding sessions; Duet for background agents that monitor, report, and act on schedules.
### Does Duet support the same MCP integrations as Claude Code?
Duet has its own integration framework for connecting agents to external tools and APIs. Claude Code uses MCP for tool integrations. Both platforms allow agents to connect to external services; the difference is in how they are configured and managed.
---
Source: https://duet.so/guides/duet-vs-codex
# Duet vs OpenAI Codex: Cloud IDE vs Agent (2026)
*Compare Duet and OpenAI Codex for AI agent workflows. Codex is a multi-agent coding tool; Duet is a cloud dev environment with a persistent always-on agent.*
By David. Published 2026-02-23, updated 2026-05-08. 10 min read.
# Duet vs. OpenAI Codex: Choosing the Best AI Coding Tool in 2026
Quick Summary
OpenAI Codex is a cloud AI coding agent that runs parallel AI agents on software engineering tasks inside sandboxed environments. Duet is a persistent AI agent platform for teams, it handles coding, email, research, ops, and GTM with always-on agents, shared context, and 10,000+ integrations. If your team needs more than a coding agent, Duet is the stronger OpenAI Codex alternative.
Questions this page answers
- What is OpenAI Codex and how does it work?
- What is the difference between OpenAI Codex and Duet?
- What are the best OpenAI Codex alternatives for teams?
- Does OpenAI Codex support team collaboration?
- Can OpenAI Codex replace developers?
- How does OpenAI Codex pricing compare to Duet?
- What is a persistent AI coding agent?
- What is an agentic coding workflow?
If you’re looking at OpenAI Codex, chances are you’re trying to move faster on engineering.
And to be fair, it delivers.
Spinning up parallel AI agents to handle coding tasks is a big step forward.
But here’s where most people pause. Once the code is written… what happens next?
Because real work doesn’t stop at engineering. There’s research, communication, ops, coordination, and that’s usually where things start to feel disconnected again.
Duet is built for that second layer. It’s not just about generating code, but about having an always-on AI system that works across your entire team with shared context.
So instead of asking which tool is “better,” it’s more useful to ask, which one actually fits how your team works day to day?
Let’s get into it.
---
## What is OpenAI Codex?
Codex is OpenAI's cloud AI coding agent, bundled into ChatGPT subscriptions. Each task runs in an isolated cloud sandbox preloaded with your repository. It runs parallel AI agents, 3 to 5+ simultaneously, on separate software engineering tasks, delivering pull requests and code changes without manual step-through.
Key characteristics:
- Cloud-based sandboxed execution for coding tasks
- Multi-agent parallel workflows (3-5+ agents on separate tasks)
- Automated git worktree management per agent
- GitHub + Slack integration for PR reviews and task delegation
- Developer-focused built by engineers, for engineers
## What is Duet?
The OpenAI Codex Alternative for Full-Stack Teams
Duet is a persistent AI agent platform, and the most complete OpenAI Codex alternative for teams that need more than just code.
Every user and team gets a private cloud server with an always-on AI agent, persistent memory, 10,000+ managed integrations and MCP tools, built-in scheduling, and a session-based workspace your whole team uses together.
Unlike Codex, Duet's agents don't die when the task ends, they persist, accumulate organizational context, and work proactively while you're offline.
---
## Duet vs OpenAI Codex: Full Feature Comparison (2026)
| | Duet | Codex |
| ------------------ | ----------------------------------------------------------- | ------------------------------------------------------- |
| Scope | Full-stack: coding, ops, GTM, email, research, integrations | Software engineering only |
| User model | Team (shared workspace, sessions, files, and org context) | Individual developers (each managing their own agents) |
| Persistence | Always-on agent with persistent memory | Task-based — agents spin up and die per task |
| Collaboration | Team-wide shared context and durable session history | No cross-user collaboration; each developer is isolated |
| Models | Claude Opus, Sonnet, GPT-5, multi-model routing | GPT-5.x-Codex models only |
| Integrations | 10,000+ out of the box (managed connectors + MCP) | GitHub + Slack only |
| Non-code workflows | Email, research, scheduling, automation, integrations | Not supported |
| Internet access | Full internet access for web search, APIs, scraping | Disabled during execution (security sandbox) |
| Scheduling | Built-in cron and event-driven automation | Automations feature (cloud triggers coming) |
| Platform | Web + mobile (cross-platform) | macOS desktop app + web (Windows planned late 2026) |
| Pricing | Monthly plans with included credits and reserve overage | $20–200/month per user + variable credits |
---
## Where OpenAI Codex Wins
Parallel AI agents. Codex's core innovation is running 3-5+ parallel AI agents simultaneously, each in an isolated worktree working on a separate feature or bug fix. The visual dashboard shows progress across all agents, a genuinely powerful agentic coding workflow for engineering teams managing multiple concurrent tasks.
Deep GitHub integration. Codex auto-reviews PRs, can be assigned tasks via '@Codex' in Slack, and proposes pull requests directly. The tight GitHub workflow integration makes it a strong AI coding agent for software engineering teams already in the GitHub ecosystem.
Long-horizon autonomy. GPT-5.3-Codex is a genuinely autonomous AI coding agent that can work independently for hours or days on complex tasks, the model was literally 'instrumental in creating itself' according to OpenAI.
Sandboxed AI agent execution. Each task runs in a container with internet access disabled, preventing data exfiltration. This is a strong security posture for enterprise AI agent deployments, though it limits what agents can do externally.
## Why Teams Choose Duet Over OpenAI Codex
10,000+ managed AI agent integrations, Codex integrates with GitHub and Slack only.
Duet ships with 10,000+ managed integrations and MCP tools, connecting your persistent AI agent to Linear, Gmail, Google Calendar, Notion, HubSpot, and thousands more, out of the box.
Beyond code, its a a full-stack AI agent. Codex is a software engineering tool. It doesn't manage email, research competitors, handle GTM, automate operations, or integrate with business tools. Duet's persistent AI agent handles the full operational stack, making it the OpenAI Codex alternative for teams whose work goes beyond the codebase.
Collaborative AI agent workspace
Codex's 'team' features are admin controls and billing, not collaborative workflow design. Each developer manages their own agents in isolation. Duet is a collaborative AI workspace: members share durable sessions, files, apps, and organizational context around the same persistent agent.
Persistent AI agent memory
Codex agents spin up per task and die when done, no memory of previous tasks, no accumulated organizational knowledge. Duet's persistent AI agent remembers every decision, preference, and project context across sessions. It gets smarter the longer your team uses it.
Always-on AI agent
Codex runs tasks on-demand. Duet's always-on AI agent runs 24/7, monitoring connected systems, triaging email, running scheduled automations, and responding to events without being explicitly invoked. It works while you sleep.
Full internet access
Codex disables the internet during execution for security, agents can't fetch external data, hit APIs, or browse the web while working. Duet's AI agent has full internet access for web search, API calls, scraping, and real-time data retrieval during task execution.
Multi-model AI agent routing
Codex only runs GPT-5.x models. Duet routes to the best model per task, Claude Opus for complex reasoning, GPT-5 for code generation, Sonnet for fast responses, giving you a multi-model AI agent that optimizes for quality and cost automatically.
Predictable AI agent pricing
Codex combines plan tiers and variable credits. Duet offers monthly plans with included credits; a workspace designates an owner as payer who manages methods, reserve topups, limits, and history. Compare the current plans against your expected workload.
---
## Who Should Choose OpenAI Codex vs Duet?
Choose Codex if:
- Your primary need is parallelized AI coding running multiple agents on separate features simultaneously
- Your team is all engineers and all work is code
- You're already in the ChatGPT ecosystem and want tight GitHub/Slack integration
- You don't need persistent agents, team-wide context, or non-code workflows
Choose Duet if:
- You need AI agents for more than just code email, research, ops, GTM, scheduling
- You're a team that needs shared context and collaborative AI workflows
- You want an always-on agent with persistent memory, not task-based ephemeral agents
- You want multi-model flexibility and predictable pricing
---
## OpenAI Codex vs Duet for Teams in 2026
OpenAI Codex is a best-in-class cloud AI coding agent for software engineering teams running parallel tasks against a codebase.
But it's a vertical tool, software engineering only, individual-focused, task-ephemeral. Its agents don't persist, don't accumulate organizational memory, and can't operate beyond the repository.
Duet is a horizontal persistent AI agent platform where agents participate in your entire operation, from coding to email to go-to-market, with shared context, always-on availability, and a collaborative AI agent workspace your whole team uses together.
If you're an engineering team that only needs a parallel AI coding agent for software tasks, Codex is a strong choice. If you're a team that needs persistent AI agents across coding, ops, and GTM, with shared context and always-on execution, Duet is the OpenAI Codex alternative worth exploring.
Ready to try Duet? Deploy your agent in one click.
## Frequently Asked Questions
### What is the main difference between Duet and OpenAI Codex?
OpenAI Codex is a code generation model and API, it converts natural language to code and powers tools like GitHub Copilot. Duet is a complete cloud AI agent platform built for teams, not just a model. Duet runs persistent agents that execute tasks, automate workflows, and operate on schedules. Codex is an ingredient; Duet is a finished product.
### Can Duet use OpenAI Codex under the hood?
Duet is primarily built on Claude (Anthropic's model). While the platform's architecture could support multiple models, Duet's workflows are optimised for Claude. Teams choosing between Duet and Codex-based tools are typically choosing between different AI backends and different product philosophies.
### Is OpenAI Codex better at coding than Duet's AI?
Codex was specifically optimised for code generation, and tools built on it (like Copilot) excel at inline code completion. Duet uses Claude, which is strong at reasoning, instruction-following, and multi-step task execution, making it better suited for complex agent workflows. For pure autocomplete, Codex-based tools are competitive; for orchestrated agent tasks, Claude-based tools like Duet have an edge.
### What can Duet do that OpenAI Codex can't?
Duet provides a complete agent platform, persistent execution, scheduling, team workspaces, tool integrations, and workflow automation. Codex is a model API that requires you to build these capabilities yourself. If you want agents that run automatically and work for your team, Duet is the ready-to-use option.
### Which is better for a startup Duet or building on OpenAI Codex?
Duet provides immediate productivity for most startups without engineering investment. Building on Codex makes sense if you're creating a product that needs custom AI-powered coding features at the API level. For internal team automation and workflow management, Duet delivers results faster than building on a raw model API.
### How does pricing compare between Duet and OpenAI Codex?
OpenAI Codex charges per token via the API, costs scale with usage and require your own infrastructure. Duet's monthly subscriptions include cloud execution and credits, with a paid reserve for overage. For highly variable or low-volume usage, pay-per-token Codex API access may be cheaper.
---
Source: https://duet.so/guides/duet-vs-conductor
# Duet vs Conductor: Which AI Agent Platform is Better?
*An honest comparison of Duet and Conductor. Local Mac execution vs cloud dev environments. See which AI agent runner is right for your team.*
By Duet Team. Published 2026-02-23, updated 2026-05-08. 6 min read.
# Duet vs. Conductor: Choosing the Best AI Agent Platform
Conductor (by Melty Labs) is a macOS app that lets you run multiple Claude Code or Codex agents in parallel on your local machine. Duet is a managed cloud platform where AI agents run 24/7 with team context. Both aim to make AI agents more useful for real work — but they take very different approaches.
---
## What is Conductor?
Conductor is a **macOS desktop application** that runs multiple AI coding agents simultaneously on your Mac. Built by a YC-backed 4-person team, it treats Claude Code and Codex instances like a team of junior engineers — dispatch them in parallel, review diffs, merge the best results.
**Key characteristics:**
- Parallel execution of Claude Code and Codex agents
- Automated git worktree management per agent
- Visual dashboard for monitoring agent progress
- Diff-first code review workflow
- Free software — you pay only for your existing AI subscriptions (Claude API, Claude Max, etc.)
- macOS only (Apple Silicon required)
## What is Duet?
Duet is a **cloud dev environment** that gives every user and team a private cloud server with a persistent, always-on AI agent. Your agent has its own server with persistent memory, 500+ integrations out of the box, built-in app hosting, and scheduling — with a shared workspace where people assign work in durable sessions and inspect the resulting events and artifacts.
---
## Head-to-Head Comparison
| | Duet | Conductor |
| ----------------------- | ---------------------------------------------- | ------------------------------------------------- |
| **Where it runs** | Managed cloud (24/7) | Your Mac (local, stops when machine sleeps) |
| **Scope** | Full-stack: coding, email, research, ops, GTM | Coding only (parallel agent dispatch) |
| **User model** | Team (shared workspace, sessions, org context) | Single user on a single Mac |
| **Agent models** | Claude Opus, Sonnet, GPT-5, multi-model | Claude Code and Codex only |
| **Persistence** | Always-on agent with persistent memory | Git commits only — no session memory |
| **Collaboration** | Team-wide shared context | None |
| **Integrations** | 500+ out of the box (managed connectors + MCP) | None |
| **Scheduling** | Built-in cron, event triggers | None |
| **Platform** | Web + mobile (cross-platform) | macOS only (Apple Silicon) |
| **Enterprise features** | Team billing, org management, permissions | None |
| **Orchestration** | Workflow orchestration with dependencies | Parallel execution only (no agent chaining) |
| **Pricing** | Monthly plans with credits and reserve overage | Free (BYOK for AI APIs) |
| **Maturity** | Production product | Early stage (v0.36, 4-person team, $500K funding) |
---
## Where Conductor Excels
**Parallel coding speed.** Conductor's core feature — running 3-5+ Claude Code agents on separate tasks simultaneously — is excellent for developers who want to parallelize coding work. Dispatch multiple features, review diffs, merge winners.
**Zero additional cost.** Conductor itself is free. You use your existing Claude or OpenAI credentials. No new subscription needed.
**Local execution.** Everything runs on your machine. If you're concerned about sending data to a cloud platform, Conductor keeps it local.
**Beautiful UI.** For an early-stage product, Conductor has a polished visual dashboard for monitoring multiple agents. The diff-first review workflow is well-designed.
## Where Duet Excels
**Always-on cloud agent.** Conductor stops when your Mac sleeps. Duet runs 24/7 on a cloud server — no laptop required. Your agent monitors connected systems, runs scheduled tasks, and responds to events around the clock.
**500+ integrations out of the box.** Conductor has zero integrations — it's a local agent runner with no connection to external services. Duet ships with 500+ managed integrations and MCP tools, so your agent can work with Linear, Slack, Gmail, Google Calendar, and hundreds more without any setup.
**Beyond code.** Conductor only dispatches coding agents. Duet's agent handles email, research, operations, GTM, scheduling, content creation — the full operational stack.
**Team collaboration.** Conductor is a single-user tool with zero collaboration features. Duet is built for teams — shared sessions, files, apps, organizational context, and multiple members working with the same persistent agent.
**Persistent memory.** Conductor has no concept of memory beyond git commits. Duet's agent accumulates organizational knowledge over time — decisions, preferences, context, relationships — and gets better the longer you use it.
**True orchestration.** Conductor does parallel execution, not orchestration. It can't chain agent outputs, define task dependencies, or create multi-step workflows. Duet supports scheduled and event-driven work that uses reusable instructions from Files, durable context from Train, and connected services from Integrations.
**Cross-platform.** Conductor requires a Mac with Apple Silicon. Duet works on any device with a browser — desktop, mobile, any OS.
**Production stability.** Conductor is at v0.36 with a 4-person team and $500K in funding. Early-stage software with expected rough edges. Duet is a production platform.
---
## They Could Be Complementary
These tools aren't necessarily competitors. A developer on a team using Duet could also use Conductor locally to speed up their individual coding sessions. Conductor parallelizes coding tasks on your machine; Duet orchestrates AI agents across your team in the cloud.
The question is whether you need a local coding parallelizer or a team agent platform. Most teams need the latter.
---
## Who Should Use What?
**Choose Conductor if:**
- You're a solo developer on a Mac who wants to parallelize Claude Code sessions
- Your work is 100% coding and you just want to go faster
- You don't need team collaboration, scheduling, or non-code capabilities
- You want zero additional cost (free tool, use existing API keys)
**Choose Duet if:**
- You're a team that needs shared AI context and collaborative workflows
- You want an always-on agent that works when your laptop is closed
- You need AI for more than coding — email, research, ops, GTM, integrations
- You want a production-grade platform, not an early-stage desktop app
- You need cross-platform access from any device
---
## The Bottom Line
Conductor is a clever local tool for parallelizing coding agents. It does one thing well — run multiple Claude Code sessions side by side. But it's a single-user, macOS-only, code-only, early-stage product with no persistence, no team features, and no orchestration beyond "run things in parallel."
Duet is a full team agent platform. If you need more than parallel coding sessions — and most teams do — Duet is where you should start.
**Ready to try Duet?** [Deploy your agent in one click →](https://app.duet.so/sign-in)
---
Source: https://duet.so/guides/duet-vs-openclaw
# Duet vs OpenClaw: Cloud IDE vs Personal AI (2026)
*Compare Duet and OpenClaw for AI agent workflows. Duet is a cloud dev environment with managed integrations; OpenClaw is a self-hosted personal AI.*
By David. Published 2026-02-23, updated 2026-05-08. 14 min read.
## Duet vs OpenClaw: Managed Cloud AI Agent vs Self-Hosted (2026)
Quick Summary
This comparison covers Duet vs OpenClaw - a managed cloud AI agent platform vs a self-hosted personal AI agent. OpenClaw gives individual developers full control; Duet gives teams persistent, always-on agents with managed security and 10,000+ integrations.
Questions this page answers
- What is the difference between Duet and OpenClaw?
- Duet vs OpenClaw comparison 2026
- Is OpenClaw better than Duet?
- What are the best OpenClaw alternatives for teams?
- Self-hosted AI agent vs managed cloud AI agent?
Choosing between Duet and OpenClaw comes down to one question: do you need a personal AI agent you fully control, or a managed AI agent platform your whole team can rely on?
OpenClaw is an open-source, self-hosted AI agent framework - powerful, hackable, and free to run. Duet is a managed cloud AI agent platform built for teams, with enterprise security, persistent memory, and 10,000+ integrations out of the box.
This guide breaks down the real differences - deployment, security, team features, integrations, and pricing - so you can pick the right tool for how you actually work.
However, its impressive rise also brought to light significant challenges, particularly concerning security and scalability, prompting a crucial discussion about OpenClaw alternatives.
## What is OpenClaw?
OpenClaw acts as a central, self-hosted AI agent, integrating with and executing tasks across various personal applications and system tools.
OpenClaw, formerly known as Clawdbot, rapidly ascended to prominence as a free, open-source autonomous AI agent designed for local, self-hosted deployment. It gained immense traction, achieving over 175,000 GitHub stars in an astonishingly short period. This popularity stemmed from its core promise: to provide individual power users with a model-agnostic AI agent that could be deeply integrated into their personal computing environment.
At its heart, OpenClaw connects to familiar messaging apps such as WhatsApp, Telegram, Slack, Discord, Signal, and iMessage, enabling it to act upon user requests. Beyond communication, its capabilities extend to web browsing, shell command execution, calendar management, and autonomous code execution.
This high degree of operational freedom is a testament to its design, allowing users to control every facet of their AI agent's interaction with their digital world. While its original creator has moved on to OpenAI, the project continues under community maintenance, embodying the collaborative spirit of open-source development.
## What is Duet?
In contrast to OpenClaw's self-hosted, personal approach, Duet positions itself as a managed, cloud-native AI agent platform specifically engineered for teams. It offers a compelling OpenClaw alternative by providing an always-on, persistent, and collaborative autonomous AI agent workspace without the complexities of self-hosting. Duet aims to deliver OpenClaw's level of autonomy and utility while embedding enterprise-grade security, centralized management, and team-centric collaboration features from the ground up.
Key characteristics of Duet include its one-click cloud deployment, eliminating the hours or days of configuration typically required for self-hosted solutions. It boasts an extensive library of over 10,000 managed integrations, facilitated by robust frameworks, and is designed with a team-first mentality, emphasizing shared context, collaborative workflows, and unified agent memory. The platform's always-on nature ensures agents are available 24/7, supported by built-in scheduling and cron automation.
Furthermore, Duet prioritizes security with an isolated sandbox, encrypted credentials, and network isolation, directly addressing many of the security concerns associated with self-hosted agents.
## OpenClaw Security Risks: The Trade-Off of Local Control
The fundamental appeal of OpenClaw lies in its commitment to local autonomy and the unrestricted control it offers to individual users. This powerful combination is what draws many technical users and researchers to its open-source framework.
### The appeal of local autonomy
OpenClaw's architecture is designed to grant users direct, local execution of their AI agents. This means tasks are processed directly on the user's machine, potentially reducing latency and circumventing the complexities often associated with cloud-based orchestration. Crucially, it provides raw file system access, allowing the agent to inspect, modify, and create files without the need for extensive API mediation.
For researchers experimenting with autonomous loops, solo prototypers building AI-driven automation scripts, or developers who desire absolute local control over their AI agent's operations, this unrestricted access is invaluable.
Moreover, by operating at the OS level, OpenClaw can orchestrate intricate multi-step workflows, such as generating code, writing it to disk, and then executing it, enabling sophisticated AI-driven processes.
The model-agnostic flexibility also allows users to swap between various LLM Providers, including OpenAI, Anthropic's Claude Code, or even fully local models via tools like Ollama, offering unparalleled customization.
### Security risks and "blast radius" concerns
However, the very autonomy that makes OpenClaw appealing also introduces significant security risks. Running LLM-generated code via a self-hosted AI agent without robust sandboxing presents a considerable vulnerability. This is a core issue for open-source personal AI agents when deployed at scale or in sensitive environments.
The potential consequences are severe: accidental file deletion, exposure of sensitive credentials stored in .env files, modification of critical system configuration files, silent exfiltration of data via HTTP requests, or the persistence of malicious scripts across sessions. While an individual hobbyist might accept these risks as part of experimentation, they are unacceptable in an enterprise context.
Organizations operating under stringent compliance frameworks such as SOC2 or ISO 27001 require comprehensive audit logs, strict role-based access controls, controlled execution environments, policy enforcement, and centralized logging. The "blast radius" of a mistake or a malicious skill in a self-hosted setup can be extensive, impacting the entire local system and potentially leading to a devastating data-breach scenario.
This highlights the critical need for enterprise-grade security features that are often absent in purely self-hosted, open-source solutions.
## Duet vs OpenClaw: Full Feature Comparison Table
To truly understand the differences and determine the best fit, a direct comparison of key features between Duet and OpenClaw is essential. This comparison illuminates the trade-offs between self-hosted personal autonomy and managed team-centric functionality.
This comparison underscores the primary divergence: Duet offers a managed, secure, and collaborative environment for teams, while OpenClaw provides deep local control for individual technical users, albeit with significant security responsibilities.
## OpenClaw Advantages: Why Developers Choose Self-Hosted AI
For individual developers, researchers, or power users who prioritize absolute control and a deep understanding of their AI agent's inner workings, OpenClaw presents a compelling set of advantages. Its open-source nature and self-hosted architecture cater to those who value customization and transparency above all else.
Model Flexibility
A significant strength of OpenClaw is its model-agnostic approach. Users can connect to various LLM Providers, including cloud-based services like OpenAI and Anthropic's Claude Code, or opt for fully local models through integrations with tools like Ollama.
This allows for cost optimization and enhanced privacy, as sensitive queries can remain within the user's local environment. Duet, while supporting multiple models, routes them through its managed infrastructure, offering a different approach to model selection.
Hackability and Extensibility
As an open-source project written in TypeScript, OpenClaw is inherently hackable. Users can fork the codebase, modify its behavior, and extend its functionality through its robust skills system, which supports Markdown or TypeScript.
This deep level of customization is ideal for individuals who want to experiment with novel AI agent behaviors or integrate highly specific functionalities. The project's extensive community has contributed a vast number of skills, although it's crucial to note that security researchers have identified malicious entries within this ecosystem.
Community Ecosystem
The sheer size of the OpenClaw community is a testament to its impact. The availability of thousands of community-developed skills on ClawHub offers a rich ecosystem for extending agent capabilities.
However, the community-maintained nature also means that vigilance is paramount. As noted, a significant number of malicious skills have been identified, underscoring the risks associated with unvetted community contributions. This contrasts with managed platforms like Duet, which curate and secure their integration ecosystem.
## Duet Advantages: Why Teams Choose a Managed AI Agent Platform
As organizations increasingly seek to harness the power of AI agents for business-critical operations, the limitations of self-hosted, individual-centric solutions become apparent. Duet emerges as a robust OpenClaw alternative for teams, bridging the gap between powerful autonomous capabilities and the stringent requirements of enterprise-grade security, scalability, and collaboration.
Enterprise-Grade Security and Compliance
This is Duet's paramount differentiator. Unlike OpenClaw, where users are solely responsible for security hardening and risk mitigation, Duet is built with security at its core. It operates within an isolated sandbox, ensuring that agent actions do not impact the broader infrastructure or other users. Credentials are managed securely, and network isolation prevents unauthorized external access.
The platform provides comprehensive audit logs, crucial for compliance with standards like SOC2 and ISO 27001, and implements role-based access to ensure users only have the permissions necessary for their roles. This drastically reduces the attack surface and mitigates the risk of data-breach scenarios and Shadow IT issues that can plague self-hosted setups.
Team Collaboration and Shared Context
Duet is designed for team environments. Members share durable AI sessions, files, apps, and a unified trained-memory layer according to their workspace roles. That shared context lets a team build on prior work without recreating it in each new session.
Personal AI agents like OpenClaw are inherently siloed, lacking the built-in mechanisms for team coordination. Duet's focus on shared context and multi-agent systems makes it an ideal platform for collaborative AI-driven processes.
Always-On and Managed Infrastructure
Duet provides a persistent, always-on cloud environment for AI agents. This eliminates the need for users to keep their machines running or manage costly Virtual Private Servers (VPS) for their agents to remain active. The platform handles all infrastructure management, including updates, patching, and ensuring uptime.
This is a significant advantage over OpenClaw, which typically only operates when the user's local machine is powered on, or requires considerable effort and cost to achieve a similar level of uptime via self-hosting. This managed approach also simplifies dependency management, reducing the risk of vulnerabilities introduced by outdated software.
Managed Integrations and Workflow Automation
Duet boasts over 10,000 managed integrations, covering a vast array of business tools and messaging platforms. This extensive integration ecosystem allows agents to seamlessly interact with existing workflows, from managing support tickets to orchestrating complex multi-step processes.
The platform is engineered to facilitate sophisticated multi-step workflows and multi-step reasoning, empowering teams to automate intricate business logic. While OpenClaw relies on community-contributed skills, which can be prone to security issues, Duet's integrations are curated and managed for reliability and security.
## Who Should Choose OpenClaw vs Duet?
The choice between OpenClaw and Duet, or any of the other emerging OpenClaw AI alternatives, hinges on specific user needs, technical expertise, and organizational requirements.
Choose OpenClaw if:
- You are a solo developer or a highly technical power user who demands maximum hackability and granular control over your AI agent's environment.
- You are comfortable managing your own security infrastructure and understand the risks associated with unrestricted local execution and open-source components.
- You prioritize running fully local LLM models for privacy, cost savings, or experimental purposes, and are adept at managing local environments like Ollama.
- Team collaboration is not a requirement, and the AI agent is intended purely for personal use.
- You are interested in exploring embedded execution on devices like a Raspberry Pi for specific edge AI projects, understanding the limitations and security implications.
Choose Duet if:
- You are part of a team that requires shared context, collaborative AI workflows, and persistent agent memory.
- Security is paramount, and you cannot afford the security risks, exposed instances, or potential supply chain attacks associated with unmanaged, self-hosted solutions. You need enterprise-grade security and clear audit logs.
- You desire an always-on AI agent without the burden of managing infrastructure, dependency updates, or complex configurations.
- You need a solution that "just works" with minimal setup time and offers robust integration capabilities across your existing toolset.
- You are looking for advanced features such as GUI Automation, UI-level automation, and the ability to deploy agents on a secure cloud platform like Cloudflare Workers or within Linux containers without managing the underlying infrastructure.
- You need to ensure privacy isolation and implement role-based access for team members.
## The Verdict: Duet vs OpenClaw for Teams in 2026
OpenClaw has undeniably blazed a trail as a powerful, open-source personal AI agent framework, offering unparalleled control for technical individuals seeking a deeply integrated, self-hosted setup. Its model flexibility and hackability make it an attractive proposition for experimentation and personal automation.
However, as the landscape of AI agents matures and enterprise adoption accelerates, the inherent security challenges and management overhead of self-hosted solutions become increasingly significant. This is where Duet, and similar managed platforms, offer a compelling evolution.
Duet provides the same autonomous agent capabilities, proactive automation, extensive tool integrations, and persistent memory, but within a secure, collaborative, and managed cloud environment. It eliminates the security risks, infrastructure complexity, and collaborative gaps that often limit self-hosted agents.
Ultimately, the decision between OpenClaw and its alternatives boils down to a strategic assessment of your needs. If you are a solo developer driven by curiosity and a desire for deep control, OpenClaw offers the keys to the kingdom, just be sure to fortify the doors.
For teams aiming to leverage AI agents for tangible business impact, Duet represents a safer, simpler, and more scalable path forward, delivering powerful autonomous assistance without compromising on security or collaboration.
Exploring these OpenClaw alternatives is not just about choosing a tool, but about adopting a strategy that aligns with your organization's security, operational, and growth objectives. The future of AI agents is here, and choosing the right foundation is paramount.
---
## Frequently Asked Questions
## What is the core difference between Duet and OpenClaw?
OpenClaw is an open-source, locally-run AI agent platform - it runs on your machine, your data stays local, and you manage everything yourself. Duet is a cloud-hosted platform where AI agents run on remote servers, accessible from anywhere, with team collaboration features and managed infrastructure. OpenClaw is for power users who want control; Duet is for teams who want ease of use and always-on execution.
## Is OpenClaw free compared to Duet?
OpenClaw is open-source and free to run - you only pay for AI API usage. Duet has subscription pricing that covers cloud infrastructure, team features, and managed execution. For solo developers with light usage, OpenClaw's total cost is lower. For teams running agents continuously, Duet's bundled pricing often wins on total cost and time savings.
## Can OpenClaw do everything Duet can do?
With enough configuration, OpenClaw can match many of Duet's capabilities - but requires more technical setup. Duet adds persistent cloud execution, team workspaces, built-in scheduling, and a polished UI out of the box. OpenClaw requires you to build and maintain the infrastructure yourself.
## Which is better for a non-technical team member: Duet or OpenClaw?
Duet - by a wide margin. OpenClaw requires terminal access and technical configuration. Duet provides a web interface and managed environment that non-developers can use without touching the command line. If your team includes non-technical members who need to interact with AI agents, Duet is the appropriate choice.
## Can I migrate from OpenClaw to Duet if my needs change?
OpenClaw skills are not directly portable or installable in Duet. Their reusable instructions can be adapted into Files, durable facts and sources can move into Train, and tool access can be reconnected through Integrations. The resulting work runs in Sessions, with any web tools it produces available under Apps.
## Does Duet support the same AI models as OpenClaw?
Both support Claude as a primary model. OpenClaw can be configured to work with multiple providers including OpenAI, Anthropic, and others. Duet is currently optimised for Claude-powered workflows. For teams that need multi-model flexibility, OpenClaw's wider model support may be an advantage.
---
Source: https://duet.so/guides/how-to-build-your-ai-command-center
# How to Build Your AI Command Center with Duet
*Stop juggling scattered AI tools. Build a centralized AI command center in minutes — one place for your integrations, knowledge base, automations, and custom apps.*
By Duet Team. Published 2026-03-24, updated 2026-05-08. 12 min read.
If you're using Claude Code, Codex, Cursor, or any other AI-powered platform, you've probably noticed the same problem: context lives everywhere. Knowledge is scattered across tools, memories are siloed, prompts are duplicated, and nothing talks to anything else. An AI command center fixes that — it's the single hub where your company's AI operations live.
**Quick Summary**
An AI command center is a centralized workspace where your AI agent, integrations, knowledge base, automations, and custom apps all live together. Instead of juggling scattered AI tools, you get one system that manages everything. Duet lets you build one in minutes with a private cloud server, pre-integrated apps, and team collaboration built in.
This guide walks you through building an AI command center from scratch using [Duet](/) — from setting up your workspace to connecting tools, building automations, and creating custom apps. The whole thing takes minutes, not weeks.
---
## Why you need an AI command center
Once you have multiple AI systems, agents, and apps working inside your business, things get complex fast. Context lives in one place, knowledge in another, memories somewhere else. You end up repeating yourself across tools, losing track of what each system knows, and spending more time managing AI than benefiting from it.
An AI command center solves this by giving you **one place** where:
- Your AI agent lives with persistent memory and context
- All your tools and integrations are connected
- Automations run on schedule without manual intervention
- Custom apps can be built and deployed instantly
- Your team can collaborate with the AI and each other
The alternative is setting up your own cloud server on AWS or Hetzner, installing Claude Code or OpenClaw, manually configuring every integration, and dealing with permissions, security, and team access yourself. That's a real option — but it takes days or weeks instead of minutes.
---
## Getting started with Duet
Head to [duet.so](/) and register for an account. Once you're in, your workspace looks like this:
- **Sessions in the sidebar** — each durable session holds one piece of work and its event history.
- **Session timeline in the main view** — where you assign work, follow progress, answer questions, and inspect results.
- **Files, Train, and Integrations** — grouped under Duet Computer in the sidebar.
Everything runs on a **private cloud server** that's yours. Your data stays in your environment — the AI agent, files, automations, and apps all live there. No need to worry about provisioning servers or managing infrastructure.
The other advantage: **team collaboration is built in**. If you want your team to use the AI command center, they just join — no complex permissions, no Slack/email integrations to configure. Everyone shares the same workspace, context, and tools.
---
## Choosing your AI models
Duet supports multiple AI models with different trade-offs:
| Model | Strengths | Best For |
| ----------------- | -------------------------------- | --------------------------------- |
| **Claude Opus** | Most intelligent, deep reasoning | Complex analysis, nuanced tasks |
| **Claude Sonnet** | Fast, capable | Day-to-day tasks, quick responses |
| **Codex** | Code-focused, strong reasoning | Development, technical workflows |
| **GPT 5.4** | Fast, versatile | General tasks, quick iterations |
You can switch models per-message using the model selector in the compose bar. All models are thinking models — they're agents that can use tools like web search, file creation, code execution, and more. If you've used Claude Code or Codex before, you'll feel right at home.
Token usage and cost are shown at the bottom of each message, so you always know what you're spending.
---
## Building your knowledge base
A command center without context is just a chatbot. The real power comes from building up a knowledge base that the AI can draw on for every interaction.
### Files and Train
Open **Files** in the sidebar to work with material on your server, and use **Train** for context the agent should carry across Sessions:
- **Source files** — documents, examples, and other material the agent can read and edit.
- **Instructions and playbooks** — reusable files that describe how you want the AI to approach recurring work. You own and edit them like any other workspace file.
- **Train facts and sources** — durable knowledge and connected sources that should remain available beyond one Session.
When something should outlive the current Session, add it to Train as a concise fact:
> "Our Q2 target is $500K ARR, and our main competitor is Acme Corp."
This is how you go from a generic AI to one that actually knows your business.
### Editing the knowledge base
Files keep your source material and playbooks inspectable; Train owns durable facts and connected sources. That split gives you control over what the agent can reference without hiding important business context inside one conversation.
---
## Connecting your tools
The knowledge base gets really powerful when you connect the tools you already use. Duet comes with **pre-built integrations** for:
- **Knowledge bases:** Google Drive, Notion, Confluence
- **Task management:** Trello, Asana, Linear
- **Data & analytics:** PostHog, Power BI
- **Communication:** Slack, email, calendar
- **CRMs:** HubSpot, Salesforce, Attio
To connect a tool, go to **Integrations** in the sidebar, find the app, and click **Connect**. You'll authorize access, and that's it — no API keys to manage, no webhooks to configure.
Once connected, you can reference these tools in conversation:
> "Hey Duet, describe what's in my Google Drive."
You can also explicitly add integrations to a conversation using the integrations selector in the compose bar, which ensures the AI uses that specific tool in its response.
---
## Setting up scheduled automations
This is where an AI command center starts to feel like a real operations hub. Automations let you set up tasks that run on a schedule — no manual intervention needed.
### Creating a scheduled task
Navigate to **Scheduled Tasks** in the sidebar. You'll see any existing cron jobs, and you can create new ones. The easiest way? Just ask the AI:
> "Hey Duet, create a scheduled task that checks for new files in my Google Drive every morning and reports what it finds in this session."
The AI will:
1. Create a cron job (a scheduled task on your server)
2. Configure it to run at the time you specified
3. Save the results in the session and workspace files
You can verify the task exists in the Scheduled Tasks panel, and edit or delete it anytime.
### Examples of useful automations
- **Morning briefing:** Summarize new emails, calendar events, and Slack messages every day at 8am
- **CRM monitoring:** Check for new leads or closed deals and save a workspace report
- **Competitor watch:** Search the web for competitor mentions weekly and compile a report
- **Content pipeline:** Check your editorial calendar and remind you about upcoming deadlines
The key insight: the AI agent manages the entire automation system itself. You describe what you want in plain English, and it handles the scheduling, execution, and reporting.
---
## Building custom apps
This is where things get genuinely powerful. The AI can build fully functional web apps inside your workspace — the same way you'd build in Lovable or Bolt, but integrated with all your existing tools and data.
### Example: meeting prep form
Here's a real example from the video. The prompt:
> "Hey Duet, create an app — a meeting prep form. Before I have a meeting with someone, I want to ask them what questions they have for me. When it's submitted, create a page in Notion with the responses."
The AI builds the entire app: a form with fields for name, email, and questions. It handles the Notion integration automatically. The result is a shareable URL that anyone can fill out, and every submission creates a structured database entry in your Notion workspace.
**One prompt. A working app. Connected to your tools.**
Now take it further. Share that URL with your team. Your cofounder sends it to every prospect before a call. Your ops lead uses the Notion database to prep briefing docs. What started as a personal tool becomes something your whole team depends on — and you built it in under a minute.
Some teams take this even further. We've seen users build internal dashboards that pull from multiple APIs, add login so their teammates each get a personalized view, and run scheduled updates so the data is always fresh. They're not just building tools — they're shipping internal products to their team using nothing but natural language.
### Why this matters
Most small teams pay for dozens of point-solution SaaS products:
- One app for scheduling
- One for meeting notes
- One for your CRM
- One for task management
- One for design brainstorming
Each costs $10-30/month, each has its own login, and none of them talk to each other seamlessly. Inside your AI command center, you can replace most of these with **custom-built apps that are designed around your exact workflow** — built in minutes with a single prompt. And because everything runs on your server with your integrations already connected, there's no glue code, no webhook configuration, and no separate hosting to manage.
---
## One system for all your tools
The whole point of an AI command center is consolidation. Instead of:
- Context scattered across Claude, ChatGPT, Gemini, and Cursor
- Integrations configured separately in every tool
- Automations split between Zapier, Make, and n8n
- Custom tools built in Lovable but disconnected from your data
You get **one system** where the AI has full context, every tool is connected, automations run natively, and custom apps live alongside your sessions.
| Before | After |
| ------------------------------------- | ----------------------------------------- |
| Multiple AI tools with siloed context | One AI with durable, shared context |
| Manual integration setup per tool | Pre-built integrations, one-click connect |
| Separate automation platforms | Native scheduled tasks, managed by AI |
| Disconnected point-solution apps | Custom apps built on demand |
| Solo AI usage, complex team setup | Team collaboration built in |
But the real unlock goes beyond personal productivity. When your apps, automations, and integrations all live in one place, something interesting happens: the things you build start becoming useful to your whole team. That meeting prep form from earlier? Share the URL with your team. The competitor dashboard you built with one prompt? Your cofounder checks it every morning.
This is the difference between a tool builder and an app platform. Other AI coding tools will help you build something — but then you're on your own for hosting, auth, and getting it in front of people. Inside your AI command center, every app you build is already live, already connected to your data, and already shareable with your team. One prompt gets you from idea to something your whole team relies on.
For the founder-level operating playbook that pulls the command center, reusable instructions, and memory together into one daily rhythm, see [Duet AI for Founders: Founder Mode as an Operating System](/guides/duet-ai-for-founders).
---
## FAQ
### What tools can I connect to my AI command center?
Duet supports hundreds of integrations out of the box — Google Drive, Notion, Slack, Linear, Trello, Asana, HubSpot, PostHog, Power BI, and many more. New integrations are added regularly, and you can also build custom integrations using the AI's code execution capabilities.
### Do I need technical skills to set up an AI command center?
No. Everything from connecting tools to building automations to creating custom apps is done through natural language conversation with the AI. If you can describe what you want, the AI can build it.
### How is this different from just using Claude Code or Codex directly?
Claude Code and Codex are powerful but require your own infrastructure — you need to set up a cloud server, manage security, configure integrations manually, and handle team access yourself. Duet packages all of that into a managed platform where everything is pre-configured and ready to use.
### Can my whole team use the AI command center?
Yes. Team collaboration is built into Duet — members join your workspace and can access shared sessions, the AI coworker, files, and apps according to their role. No additional infrastructure setup is needed.
### How much does it cost?
Duet offers a 7-day free trial to get started. After that, Starter, Pro, and Max include monthly credits, with a paid reserve for overage. Check [Duet pricing](/pricing) for the current plans.
### Can I build apps that other people outside my team can use?
Yes. Apps built in your workspace can be shared via public URLs. For example, the meeting prep form in this guide generates a link that anyone can access — no Duet account required.
---
Source: https://duet.so/guides/how-to-cut-rekeying-in-carrier-portals
# How to Cut Rekeying in Carrier Portals with AI
*Reduce carrier portal rekeying with AI that extracts ACORD data and powers automated carrier submissions across portals.*
By Duet Team. Published 2026-03-06, updated 2026-04-19. 10 min read.
# How to Eliminate Manual Rekeying in Carrier Portals with AI
Quick Summary
This guide covers how insurance agents can use AI to reduce manual rekeying in carrier portals. Automating data entry, form population, and submission workflows that currently eat hours every week.
Questions this page answers
- How to reduce rekeying in carrier portals with AI
- AI tools for insurance carrier portal automation
- How to automate insurance data entry with AI
- Can AI fill out carrier portal forms automatically?
- What is carrier portal rekeying and how can AI help?
## What is carrier portal rekeying?
Carrier portal rekeying is the redundant process of manually entering the same insurance client data multiple times across different carrier systems to generate quotes. Using AI automation tools, agencies can extract ACORD form data and automatically populate these carrier portals, eliminating duplicate data entry and reducing errors.
Rekeying is one of the biggest hidden time drains in independent insurance agencies.
The same client data gets entered into your AMS, carrier portals, quote forms, emails, and internal notes.
AI can reduce carrier portal rekeying by extracting, structuring, and organizing client and policy information before it ever gets retyped across systems — turning manual data entry into automated carrier submissions that free producers to focus on client work.
## Why Manual Rekeying Hurts Insurance Agency Margins
Independent agencies spend an estimated 15-20 hours per week on redundant data entry. That is not a single bottleneck you can fix by hiring one more CSR. It is spread across quoting, submissions, endorsements, and renewals, which makes it invisible on any individual task but devastating in aggregate.
The real cost is not just labor. Manual rekeying introduces field-level errors that cascade through the quoting process. A mistyped effective date, a wrong class code, or an outdated address can trigger a decline or delay that takes longer to fix than the original entry. Agencies that track their rework rate typically find that 10-15% of submissions require at least one correction loop, and each loop adds 20-45 minutes of back-and-forth with the carrier.
### The Hidden Costs of Redundant Data Entry
Beyond the direct time cost, redundant data entry creates three problems that rarely show up in productivity reports:
- **Employee burnout**: CSRs and account managers who spend most of their day copying information between systems report lower job satisfaction and higher turnover. Replacing a trained insurance professional costs an agency $15,000-25,000 in recruiting and onboarding.
- **Compliance risk**: When the same data exists in multiple systems without a single source of truth, discrepancies create E&O exposure. If the named insured on the application does not match the policy, or if the wrong limits appear in a certificate, the agency bears the liability.
- **Missed revenue opportunities**: Every hour spent on data entry is an hour not spent on cross-selling, remarketing, or building client relationships. Agencies that have reduced rekeying by 50% or more consistently report that their producers spend more time on revenue-generating activities.
## 3 Steps to Automate Carrier Portal Submissions with AI
The most effective approach to automated carrier submissions uses AI as a data extraction and normalization layer that sits between your existing systems. You do not need to replace your AMS or wait for carrier APIs.
**Step 1: Extract data from intake documents.** Feed ACORD forms, dec pages, loss runs, and intake emails into an AI agent. The agent pulls structured fields (named insured, addresses, policy dates, coverages, limits) and flags anything missing or ambiguous. This replaces the manual read-and-retype step that starts every new submission.
**Step 2: Standardize into a carrier-ready payload.** Different carriers expect different field formats, label conventions, and document structures. AI normalizes your extracted data into a consistent format that maps to the most common carrier portal fields. One extraction feeds multiple carrier submissions instead of each portal requiring its own manual entry pass.
**Step 3: Automate the portal fill.** For carriers with browser-based portals, browser automation tools can populate fields directly from your normalized data. For carriers with API access or download-upload workflows, the same data feeds directly into their intake format. The agent flags any field it cannot confidently fill and queues it for human review.
## Where Rekeying Wastes Time in Insurance Agencies
The drag does not come from one giant task. It comes from the same information being handled repeatedly at different points in the workflow.
The biggest time leaks show up in four places:
| Rekeying Area | What Happens |
| ------------------------ | ------------------------------------------------------------------------------------------ |
| Intake to AMS | Client and risk details pulled from emails, PDFs, or intake forms and entered into the AMS |
| AMS to carrier portals | The same information retyped across multiple carrier portals during quoting |
| Follow-up communications | Emails or notes rewritten manually after each quote, change, or submission step |
| Correction loops | One address, VIN, effective date, or named insured field does not match across systems |
Each step may only take a few minutes on its own. But across new business, remarkets, policy changes, and renewals, the weekly total adds up fast.
## Workflow to Reduce Carrier Portal Rekeying in a Working Agency
You do not need to rip out your AMS or wait for every carrier to modernize its portal.
What works today is simpler: use AI as the layer that extracts, structures, and reuses information before your team starts typing it into multiple systems.
### Turn Client Intake Into a Structured AI-Ready Summary
Convert whatever came in (email notes, PDFs, ACORD forms, declarations pages, or internal intake notes) into one clean summary.
That summary should include:
- Client profile
- Risk details
- Current policies or prior carrier information
- Coverage goals
- Open questions or missing fields
The goal is to stop working from messy source material once the submission process begins. If you handle commercial lines, this step overlaps with ACORD form and quote prep workflows.
### Create One Normalized Data Packet for All Carriers
Turn that summary into a single "working packet" your team can reference across quoting and submission.
This packet becomes the source you use while entering information into carrier portals, preparing internal notes, or checking follow-up items. Instead of rereading the same documents each time, the team works from one cleaned-up version of the file.
### Generate Carrier-Specific Entry Checklists Automatically
Before anyone starts portal entry, use the same packet to create a short checklist for each carrier.
That checklist can call out:
- Fields that are usually required
- Details commonly missed
- Supporting documents needed
- Questions that still need clarification before submission
This reduces the back-and-forth that happens when a portal flags missing information halfway through the process.
### Draft Policy Updates and Endorsements From the Same Source
Once quoting is in motion, use that same packet to draft client updates, internal notes, or follow-up emails.
Your team is not rewriting the same account summary from scratch every time there is a quote update, a carrier question, or a next-step email to send. For a deeper look at streamlining those client updates, see how to speed up client emails and renewal follow-ups.
## Example AI Prompt to Eliminate Rekeying in Carrier Portals
> Turn the following intake notes into: (1) structured client summary, (2) missing info checklist, (3) carrier-entry packet. Keep output in bullet format and flag assumptions.
Then paste your notes (with sensitive identifiers removed).
## What to Check Before Automating Rekeying
Use anonymized or sanitized information when working in general-purpose AI tools. Avoid putting
SSNs, DOBs, full policy numbers, full claim numbers, full addresses, VINs, or driver's license
numbers into a public tool unless your agency has explicitly approved it with the right
data-handling terms in place.
A simple rule that works for most agencies:
- Safe: Structuring information, drafting language, creating checklists, building email templates, summarizing redacted documents, writing "what questions should I ask" agendas
- Not safe: Raw sensitive PII, unredacted declarations pages, and claim-identifying details
If you want to start today, start with redacted samples and build the workflow first. Then decide what tools and settings you need to handle live client data responsibly.
## Tracking ROI From Rekeying Automation
Do not try to measure everything at once. In week one, focus on three indicators:
- Time from intake to quote-ready packet: How long does it take to go from incoming client information to a clean packet your team can use for quoting and portal entry?
- Number of rework loops per quote: How often does the team have to go back and fix missing, inconsistent, or mismatched information?
- Response time for client updates: How quickly can you send a clear client update after a quote step, carrier response, or request for more information?
If those numbers start moving in the right direction, the workflow is doing its job.
## Frequently Asked Questions
### What is rekeying in insurance and why is it a problem?
Rekeying is the process of manually entering the same data into multiple systems - copying client information from an application into three different carrier portals. It is one of the biggest time drains in independent insurance agencies, prone to errors, and adds no value. Agencies estimate rekeying consumes 20-40% of CSR time.
### How does AI reduce rekeying in carrier portals?
AI can read data from one source and automatically populate fields in carrier portals using browser automation or API integrations. Instead of a CSR manually copying 50 fields per submission, an AI agent handles the extraction and entry - the CSR reviews and submits.
### What tools can automate carrier portal data entry?
Browser automation tools like Playwright combined with AI can navigate carrier portals and fill forms. Platforms like Duet can run these automations as persistent agents. Some carriers also offer API access for direct data submission, which is more reliable than browser automation when available.
### Is AI-powered rekeying automation reliable enough for insurance submissions?
For standard personal lines submissions, yes. For complex commercial submissions with many edge cases, human review remains essential. The right model is AI handling first-pass data entry and a CSR reviewing for accuracy before submission.
### Will automating rekeying cause compliance issues?
Not if implemented correctly. The agent fills forms based on data the agent provided - the same data a human would enter. Licensed agents remain responsible for reviewing and submitting. Always have a licensed agent approve submissions before they go to carriers.
### How long does it take to set up rekeying automation for a carrier portal?
A basic automation for a single carrier portal typically takes a few hours to a day to build and test. Browser-based automations require periodic maintenance when portals update their UI. Starting with your highest-volume carrier first gives the fastest ROI.
### What is the fastest way to reduce carrier portal rekeying across an agency?
The fastest way to reduce carrier portal rekeying is to standardize intake first, then layer automation on top. Build one normalized data packet per account — pulled from ACORD forms, dec pages, and intake notes — and reuse it across every carrier portal. Agencies that pair intake standardization with browser automation or API-based automated carrier submissions consistently report 50-70% reductions in data-entry time within the first 60 days, without replacing their AMS.
---
Source: https://duet.so/guides/how-to-set-up-duet
# How to Set Up Duet: A Founder Walkthrough for Your AI Workforce
*How to set up Duet for a real first job: start a durable session, organize files, train reusable context, connect integrations, and ship apps.*
By David Zhang. Published 2026-05-19, updated 2026-05-19. 19 min read.
**Quick Summary**
Duet gives every workspace a private cloud VM and a persistent AI coworker. To set it up: (1) start one durable session with a real outcome, (2) organize workspace files like you would brief a new hire, (3) add stable facts and sources to Train, (4) keep scheduled results in session history and files, (5) connect tools through Integrations, and (6) ship internal or external apps from the same workspace. Specific context matters more than novelty.
This guide is the exact walkthrough David, Duet's founder, gives to new customers on their first call. It is not a feature tour. It is the order of operations that turns a new workspace into a working AI coworker — what to do first, what to skip, and the mindset shifts that separate the people who get 10x value from the people who treat Duet like a fancier ChatGPT.
If you just signed up, read this once before you do anything else. If you're an implementation partner setting up Duet for a client, this is the playbook.
## 1. Start with one real session
Duet opens on Sessions: a list of durable pieces of work. Start with one real outcome instead of trying to configure the entire workspace at once.
The biggest predictor of a useful first result is the quality of the brief: the desired outcome, the source material, the constraints, and the test that tells the agent it is done.
Think of it like this. If you transplanted every memory you have into another person's brain, that person would behave a lot like you — same opinions, same instincts, same shortcuts. The model is the brain. Your memory is what makes Duet act like _your_ coworker instead of a generic assistant.
Start a session with one real job. Upload the sales deck, strategy document, ICP notes, style
guide, or other files the job depends on, then state what a finished result must contain.
When the session asks a question, answer it directly. The answer becomes part of that durable work history instead of disappearing after a one-off prompt.
Duet builds memory implicitly through conversation and explicitly through the memory file. You're not retraining the model. You're giving it context.
## 2. Garden your knowledge base
The Files tab in your workspace is a real file system on a real cloud server. You can upload PDFs, drag in folders, paste URLs (Duet will scrape them into markdown automatically), and Duet can read everything in there.
The way to think about it: **set it up the way you would organize a Google Drive for a brand new employee.**
```
/files
/company
one-pager.pdf
pitch-deck.pdf
style-guide.md
/customers
target-icp.md
case-studies/
/products
pricing.md
roadmap.md
/sales
discovery-questions.md
objection-handling.md
```
This is what David calls "gardening." You don't have to do it constantly. A quick sanity check every couple of weeks is enough — move anything that obviously belongs somewhere else, prune anything stale.
A well-organized memory file links to sub-memories, which link to other files. The agent navigates your file system the same way you do. Better structure = smarter coworker.
The Files API exposes the same workspace file tree as the web app, so automated workflows can
create, read, move, and publish artifacts without a second storage model.
## 3. Train reusable context
Train is where a workspace keeps stable facts and sources that should be reusable across sessions. Add a short record directly, upload source material, or provide a URL for the workspace to process.
After a strong session — for example, an SEO audit with the right internal-link, cannibalization, AEO, and ranking checks — extract the durable facts and standards that future work should reuse.
> "Save the stable SEO criteria and our company-specific priorities so later sessions can reuse them."
Keep those standards in Train and the supporting files in the workspace. Future sessions can retrieve the same business context without inventing it again.
This is the part that does not exist in a disposable prompt window. Duet keeps the session history, trained context, and files together so useful work compounds.
Anything that has the shape: "domain expert + repeatable workflow + tedious to do every time."
Examples: weekly competitor monitoring, SEO audit per page, customer onboarding email drafting,
inbound lead enrichment, monthly board update prep. If a fact or standard should survive this
session, add it to Train.
Reusable context should be specific to your company: its keywords, priorities, terminology, customers, and trusted data sources. That specificity is the point.
## 4. Schedule recurring work
Duet's workspace VM stays available when your laptop is closed, so the agent can run scheduled jobs and keep their results in durable sessions and files.
Here is what it looks like in practice. Start a session and give the AI an instruction:
> "Every hour, check our connected support inbox. Every day at 9am, update the growth report. Every Monday, run the weekly SEO check."
Duet sets up the scheduled work on the workspace VM. Its session events and output files leave an inspectable record of what ran and what changed.
The big win over hidden cron jobs:
- **You can see what it's doing.** Not "hopefully it ran."
- **You can refine it in the same session.** "Also check Reddit while you're at it."
- **You can inspect the files it produced.** Reports remain in the workspace instead of disappearing into a scheduler log.
- **You keep one durable history.** The assignment, questions, progress, and results stay together.
Start a session and ask Duet to inventory the cron jobs on the workspace VM, explain what each one
does, and migrate only the jobs you approve. Keep the resulting runbook in workspace files.
## 5. Connect any tool with an API
Duet ships with around 500 preconfigured integrations — Google Calendar, Slack, Notion, Linear, Stripe, Gmail, Telegram, you name it. Browse them in the Integrations tab and connect with one click.
What most people miss: **Duet can connect to anything with an API, not just the 500 preconfigured ones.**
The way it works: Duet is, at its core, a coding agent. Every AI agent is. Even when you ask it to do "research" or "sales prospecting," it's actually writing and running code under the hood. So if you want to connect a random fifteen-year-old billing system that nobody else integrates with, you just ask:
> "Does Sentry have an API? Connect to it. Here's our API key."
Duet looks up the docs, writes the integration, and calls the API through the credential boundary you authorize. For catalog integrations, credentials remain with the server-side provider connection rather than being returned to browser JavaScript.
Prefer the Integrations screen for supported services. Duet keeps provider credentials on a
server-side connection boundary, scopes workspace credentials, and does not expose raw keys to
browser JavaScript or session events.
## 6. Ship internal and external apps
Because Duet has its own server and runs a coding agent, it can build apps. Real ones.
There are two flavors and you'll probably use both:
**Internal apps.** A dashboard, an admin tool, an "internal use cases" page that links to your best workflows. Duet builds them, hosts them on your server, and you can share the URL with your team. We use this constantly — every cool tab in our own Duet workspace ends up linked from one internal app we maintain.
**External apps.** A landing page, a marketing site, a customer portal. Same flow. You ask, Duet ships, the app gets a `.duet.so` URL by default, and you can wire your own custom domain (like `consigliere.com`) by setting up the DNS record. We currently host customer-facing marketing sites for several companies entirely inside their Duet workspace.
Hosting, custom domains, SSL — all included. No "deploy" button to find. The app is just there once Duet writes it.
A bartender in Texas who runs a seven-year-old bar was paying a dev agency $3,000/month for his
website. He moved his entire site into Duet and now spends about $200/month in tokens for a better
one that he can iterate on himself, in plain English.
## 7. Security and your own server
The single most important thing to understand about Duet's security model: **every workspace is its own server.**
Not a shared agent process. Each workspace receives a dedicated single-tenant virtual machine. Its files and processes are isolated from other customer workspaces.
This isn't just a marketing label; it is an architectural boundary. A dedicated computer lets Duet write code, install tools, retain files, and continue work across sessions without sharing a workspace runtime with another customer.
Practically:
- Integration credentials stay behind server-side provider connections.
- Browser sessions use secure HTTP-only cookies; raw product API keys are not exposed to browser JavaScript.
- You can browse, edit, and download workspace files through the product and API.
- VM and workspace credentials are scoped, time-bounded, and rotated by the control plane.
If you're at a company with compliance requirements, this single-tenant model is usually easier to defend than a typical multi-tenant agent platform, not harder.
## 8. Billing without surprises
Duet has three monthly plans: Starter, Pro, and Max. Two things to know.
**Monthly credits reset.** Each plan includes a monthly credit bucket. It resets at renewal and unused monthly credits do not roll over, so choose the plan around the work you expect Duet to own in a normal month.
**Overage uses your paid reserve.** When monthly credits run out, Duet draws from the paid reserve. The designated payer can refill it manually or enable auto topups; every subscription charge and topup produces an invoice.
**How to avoid sticker shock.** Three settings, all in your billing page:
| Setting | What it does | Recommended |
| --------------------- | -------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| Spend cap | Hard ceiling per month. Duet stops at this number. | Set it to your real budget. |
| Auto top-up amount | How much credit gets added when you run low. | $20 minimum for casual use; higher if you use Duet hard. |
| Auto top-up threshold | The balance at which auto top-up kicks in. | Don't set this too low — usage comes in bursts of $5–$50 at a time, and your credit card processor will start blocking too-frequent charges. |
The dashboard breaks usage down per member, per day, with per-message tags. You can always see what cost what.
## 9. Pick the right model
Duet can run work through multiple model families while preserving one durable session history.
**Default to a stronger reasoning model when you're getting started.** Especially in the setup phase. It is better at instruction following and deciding whether a workflow is worth saving as a reusable playbook. The extra reasoning cost can be worthwhile while the workspace is taking shape.
Once Train context and reusable playbook files are tuned, smaller models can handle workloads that do not need the most expensive reasoning tier — Q&A over your knowledge base, drafting a quick reply, or summarizing a report.
Want to use a cheaper model on a workflow but the output isn't as good? Run the workflow on Opus
first. Then run the same prompt on Sonnet (or Gemini) and ask the cheaper model: "Keep improving
your output until it matches what Opus produced." The cheaper model will iterate, and along the
way it'll write a longer, more explicit version of the prompt that you can reuse. Cheap models
often just need more guidance — let AI write the better prompt for you.
We've tested automatic model routing in the past. It didn't work well. The models have very different personalities, and an auto-router produces a "schizophrenic" experience — sometimes great, sometimes bafflingly off, no way to know why. For now, choose the model explicitly.
## 10. Connect external services
Duet connects external systems through the Integrations screen. The agent can then use authorized actions inside a session without exposing provider credentials to the browser.
**Email.** Connect a supported email provider and give the agent a bounded task. Common patterns:
- "Summarize the email and recommend a next action. Don't reply automatically."
- "Reply to all customer support emails using our brand voice. Escalate anything refund-related to me."
- "Add the email to the right contact record and save a one-line summary to memory."
The resulting tool calls and outputs remain attached to the session that initiated them. Disconnecting the integration revokes future Duet access.
## 11. Workspace identity and app domains
Duet keeps workspace identity and published apps separate. You can:
- Rename your workspace from workspace settings, with explicit acknowledgement that public URLs may change.
- Use a custom domain for any app Duet builds.
- Set up DNS so your customers see your brand, not ours.
The only thing we don't currently support fully white-labeling is the root Duet app URL. The pragmatic workaround: build your customer-facing experience as an app inside Duet, point your own domain at it, and the customer never sees the word "Duet."
If you're an agency or partner setting up Duet for clients: the cleanest pattern is to create a
workspace on behalf of the client, configure it, then invite them as an admin and leave the
workspace yourself when you're done. The workspace is no longer tied to your account once you
leave. Make sure the client is an admin first — otherwise the workspace becomes ownerless.
## 12. The mindset shift
If you take one thing away from this guide, take this:
**Using AI well is a little like gambling.**
You're betting some tokens — call it $1, or $10, or $100 — that the AI will produce something that returns multiples of that value. Sometimes it doesn't. Sometimes the run goes sideways and you've spent $20 on nothing. But over a month, if you know roughly what you want, the expected value is heavily positive. Our top users spend hundreds of dollars in tokens a month and get tens of thousands of dollars of work back.
This mindset only works if **you know what you want.** Vague prompts on expensive models with no context in place will burn money fast. Specific outcomes, backed by Train sources and reusable instructions, are easier to evaluate and repeat.
The corollary: **don't try to learn AI by exploring randomly.** Pick one boring, valuable, repeatable workflow in your business — answering customer support emails, doing weekly SEO audits, updating your website, drafting outbound sequences, building an internal dashboard — and make Duet good at that one thing. Then add the next. People who try to "use AI for everything" on day one usually use it for nothing by week four.
## 13. FAQ
**What is Duet?**
Duet is an AI workforce platform that gives every team a private cloud server with an always-on
AI coworker. Each workspace runs on its own single-tenant virtual machine with durable sessions,
a real file system, trained memory, integrations, and the ability to build and host apps. Think
of it as hiring an AI employee, not signing up for another SaaS tool.
**Is Duet an AI workforce platform for small businesses and founders?**
Yes. Duet is designed for founders, solo operators, and small teams who want AI coworkers that
do real work, not chatbots that answer questions. Each workspace runs on its own private server,
remembers trained context and integrates with business tools through server-side connections.
Monthly plans include shared credits, so a one-person business and a fifty-person team can
choose around the work they want Duet to own rather than buying seats.
**What is the first thing I should do in a new Duet workspace?**
Start one real session and load the context it needs. Upload the files you would brief a new
hire with — sales deck, ICP, style guide, pricing notes — and describe a concrete finished
result. Add stable facts and sources to Train so they can compound across later sessions.
**What is a Duet skill?**
The agent can use reusable instructions and code stored in workspace files. The current web app
exposes Sessions, Apps, Files, Train, and Integrations; a dedicated skills-management surface is
not part of this release.
**How does Duet handle recurring work?**
Recurring work runs as scheduled jobs on the workspace VM. The AI can wake up, perform the job,
and keep its results in the durable session history or workspace files so the team can inspect
and refine the next run.
**Can Duet integrate with tools that aren't on the official integrations list?**
Yes. If the tool has an API, Duet can connect to it — even something obscure or fifteen years
old. Duet is a coding agent at its core. You give it the API docs and a token, it writes the
integration on its own server, and you query the tool from inside Duet. No MCP server required.
**How does Duet store my API keys and tokens?**
Supported integration credentials stay behind server-side provider connections and can be
revoked by disconnecting the integration. Browser credentials use secure HTTP-only cookies, and
raw API keys are not exposed to browser JavaScript or session events.
**Is Duet multi-tenant or single-tenant?**
Every workspace receives a dedicated isolated virtual machine for its files and agent processes.
The control plane scopes credentials and authorization to that workspace instead of running
every customer's agent inside one shared workspace runtime.
**How does Duet bill?**
Starter, Pro, and Max are monthly subscriptions with included credits that reset without
rollover. The designated payer manages payment methods, reserve topups, limits, and billing
history from user settings. Overage draws from that paid reserve.
**Which model should I use in Duet?**
Use the model available for the session and judge it against the job's acceptance criteria.
Expensive reasoning models fit ambiguous, long-horizon work; smaller models fit bounded
drafting, extraction, and summarization. Durable sessions and trained context should remain
useful when the underlying model changes.
**Can I white-label Duet for my clients?**
Customer-facing apps can use their own design and custom domain. Workspace settings and the Duet
product shell remain Duet-branded in this release; logo replacement and AI renaming are not part
of the current settings surface.
**How do I set up Duet for a client as an agency or implementation partner?**
Create a new workspace on behalf of the client. Configure their Train sources, playbook files,
and integrations with whatever questionnaire output and onboarding context you've gathered.
Invite the client as an admin. When you're done, leave the workspace — it no longer ties back to
your account once you leave, so make sure the client is an admin first.
**What do non-technical Duet users need the most help with?**
Coming up with the first use case. Everyone knows AI is a big deal, almost nobody knows what to
apply it to first. The fastest wins are usually low-risk and concrete: rebuild your website with
a coding agent (a few dollars in tokens vs. a $3,000/month agency), let Duet draft customer
support replies for you to review, or run a weekly competitor monitor that stores a report in
the workspace.
**What's the difference between Duet and a consumer AI computer like Perplexity Comet?**
Comet is a consumer browser-based computer. Duet gives each workspace a dedicated cloud VM,
durable sessions, workspace files, trained context, hosted apps, and server-side integration
connections intended for ongoing business work.
---
Source: https://duet.so/guides/how-to-set-up-openclaw-for-your-team
# How to Set Up OpenClaw for Your Team
*Set up OpenClaw for your team: cloud hosting, auth, permissions, and uptime. Compare $10K+ in DIY labor with Duet monthly plans.*
By David. Published 2026-03-13, updated 2026-05-08. 20 min read.
# How to Set Up OpenClaw for Your Team: A Step-by-Step Guide
Quick Summary
This guide walks through setting up OpenClaw for your team. From initial configuration and connecting messaging platforms to assigning skills and managing permissions for multiple users.
Questions this page answers
- How to set up OpenClaw for a team
- OpenClaw team setup guide
- How to configure OpenClaw for multiple users
- Best practices for OpenClaw team deployment
- What is OpenClaw and how does it work for teams?
Setting up OpenClaw for a team requires 24 to 44 hours of engineering work across cloud hosting, multi-user authentication, shared state management, role-based permissions, and uptime monitoring. The first-year total cost for a team of five is $10,000 or more when you factor in setup labor and ongoing maintenance. Managed platforms like Duet provide the same capabilities with a 3-minute signup and zero infrastructure work.
OpenClaw is one of the most powerful open-source AI agent platforms available. With 175,000+ GitHub stars and 10,700+ community skills, it gives solo developers a level of AI autonomy that rivals commercial platforms. Teams, however, face a different reality.
This guide walks through what it actually takes to configure OpenClaw for multi-user, always-on team use. Every step, every gotcha, and every hour of engineering time is documented. Then we cover the alternative: [Duet](/), which ships all of this out of the box.
{/* GRAPHIC IDEA: Hero illustration with a split screen. Left side shows a stressed developer surrounded by terminal windows, Docker configs, SSH keys, and error logs. Right side shows a team reviewing a completed Duet session and its artifacts. Caption: "Same outcome, different weekend." */}
---
## Why Setting Up OpenClaw for a Team Is Harder Than It Looks
OpenClaw was designed as a personal AI agent. It is a single-user application that runs on your laptop and connects to your messaging apps. That architecture is a feature for solo power users who want total control.
For teams, it is a wall.
Here is what you are signing up for when you try to make OpenClaw work for more than one person:
Challenge | What's Involved | Estimated Time
**Cloud hosting** | Provision VPS, Docker, systemd, SSL | 2 to 4 hours
**Multi-user auth** | Build or integrate OAuth/SSO, session management | 8 to 16 hours
**Shared state** | Configure shared conversation history, workspace sync | 4 to 8 hours
**Permissions & RBAC** | Role-based access, API key scoping, audit logs | 8 to 12 hours
**Uptime & monitoring** | Health checks, auto-restart, alerting | 2 to 4 hours
**Ongoing maintenance** | Dependency updates, security patches, backups | 2 to 4 hrs/month
**Total first-week investment: 24 to 44 hours of engineering time.**
At $100/hour, that is $2,400 to $4,400 before anyone on your team sends a single message to the agent.
{/* GRAPHIC IDEA: Horizontal timeline infographic showing the setup journey. Day 1: "Provision server." Day 2: "Configure Docker + OpenClaw." Day 3 and 4: "Build auth layer." Day 5: "Wrestle with shared state." Day 6: "Set up monitoring." Day 7: "Debug why it all broke overnight." Each step has a small icon and estimated hours. Final callout at the end: "Duet: 3 minutes." */}
---
## Step 1: Cloud Hosting for OpenClaw - VPS, Docker, and Server Setup
OpenClaw runs locally by default. When your laptop sleeps, it stops. For a team, you need a server that stays up around the clock.
### What You Need
- A VPS with 4GB+ RAM and 2+ CPU cores (Hetzner CAX11 at $5/mo is the minimum)
- Docker installed and configured
- A domain name with SSL certificates
- Firewall rules (UFW or iptables)
### Server Requirements by Team Size
Team Size | Recommended Instance | Monthly Cost | RAM | CPU Cores
1 to 2 | Hetzner CAX11 | $5 | 4GB | 2
3 to 5 | DigitalOcean Regular | $24 | 4GB | 2
6 to 10 | AWS t3.large | $60 | 8GB | 2
10+ | Dedicated or HA | $120+ | 16GB | 4+
### The Setup
```plaintext
# Provision Ubuntu 22.04 server, then:
ssh root@YOUR_SERVER_IP
apt update && apt upgrade -y
# Install Docker
curl -fsSL https://get.docker.com -o get-docker.sh && sh get-docker.sh
systemctl enable docker
# Create workspace
mkdir -p /opt/openclaw && cd /opt/openclaw
# Configure environment
cat > .env << 'EOF'
ANTHROPIC_API_KEY=your_key_here
OPENAI_API_KEY=your_key_here
WORKSPACE_DIR=/workspace
PORT=3000
EOF
chmod 600 .env
# Run OpenClaw
docker run -d \
--name openclaw \
--restart unless-stopped \
-p 3000:3000 \
-v /opt/openclaw/workspace:/workspace \
--env-file /opt/openclaw/.env \
openclaw/openclaw:latest
```
### What Can Go Wrong
- **Docker image pulls fail** due to rate limiting on free Docker Hub accounts
- **Port conflicts** if other services use 3000
- **Memory pressure** causes OOM kills on undersized instances
- **SSL misconfiguration** leaves your API keys exposed over plain HTTP
For more detail on this step, see our full walkthrough: [How to Host OpenClaw in the Cloud](/blog/how-to-host-openclaw-in-the-cloud).
{/* GRAPHIC IDEA: Architecture diagram showing the data flow from a user's laptop through the internet to a VPS running a Docker container with OpenClaw. Include volumes for workspace and .env file for secrets. Show the firewall between the internet and VPS. Annotate pain points with red callout bubbles: "Who manages SSL?", "What if Docker crashes at 3 AM?", "How do 5 people share this?" */}
---
## Step 2: Multi-User Authentication - The Hardest Part of Team OpenClaw
This is where most teams abandon the project.
OpenClaw has no built-in concept of "users." It is one agent, one operator. Everyone who hits your server sees the same conversations, the same integrations, the same API keys.
### What You Need to Build
1. **A reverse proxy with auth** (Nginx + OAuth2 Proxy, Caddy with auth middleware, or Authelia)
1. **An identity provider** (Google Workspace, Okta, Auth0, or self-hosted Keycloak)
1. **Session management** to track who is logged in
1. **Per-user isolation** or shared workspaces with attribution
### Example: OAuth2 Proxy + Google Workspace
```plaintext
# Install OAuth2 Proxy
docker run -d \
--name oauth2-proxy \
-p 4180:4180 \
-e OAUTH2_PROXY_CLIENT_ID=your_google_client_id \
-e OAUTH2_PROXY_CLIENT_SECRET=your_google_client_secret \
-e OAUTH2_PROXY_COOKIE_SECRET=$(openssl rand -hex 16) \
-e OAUTH2_PROXY_PROVIDER=google \
-e OAUTH2_PROXY_EMAIL_DOMAINS=yourcompany.com \
-e OAUTH2_PROXY_UPSTREAM=http://openclaw:3000 \
quay.io/oauth2-proxy/oauth2-proxy:latest
```
This gates access behind Google login, but it does not solve the real problem: **everyone still shares the same agent session.** There is no concept of "Sarah asked this" vs. "James asked that." No permission boundaries. No audit trail.
{/* GRAPHIC IDEA: Flowchart showing auth complexity. Start with "User opens browser" leading to "Hits Nginx" leading to "Redirects to OAuth2 Proxy" leading to "Authenticates with Google/Okta" leading to "Session cookie set" leading to "Proxied to OpenClaw" leading to "...but OpenClaw doesn't know who you are." Final box is red with text: "Authentication is not Authorization. You built a locked door, but everyone inside shares the same room." */}
### The Real Problem
Authentication tells you _who_ is at the door. Authorization tells you _what they can do inside_. OpenClaw has neither, and bolting on auth at the proxy layer only solves the first problem.
For true multi-user support, you would need to fork OpenClaw and modify its core to:
- Track user identity per request
- Scope conversations per user or team
- Implement role-based permissions (admin, member, viewer)
- Log all agent actions with user attribution
That is not a weekend project. That is a product.
---
## Step 3: Shared Agent State and Conversation History Across Your Team
On a single laptop, OpenClaw stores conversations locally. With multiple users, you need shared state.
### Options (None Are Great)
**Option A: Shared filesystem.** Mount a network volume (NFS, EFS) so all users read/write the same workspace. Works until two people trigger agent tasks simultaneously and hit race conditions.
**Option B: Database backend.** Replace local storage with PostgreSQL or Redis. Requires modifying OpenClaw's storage layer. Community forks exist but break on updates.
**Option C: Separate instances per user.** Run one OpenClaw container per team member. Solves isolation but kills collaboration. Also multiplies infrastructure cost by headcount.
{/* GRAPHIC IDEA: Three-panel comparison showing each option. Panel A: "Shared filesystem" with multiple users writing to one folder and a collision/explosion icon where two writes overlap. Panel B: "Database backend" with an OpenClaw container connected to PostgreSQL and a warning label "custom fork required." Panel C: "Instance per user" with five separate OpenClaw containers, each with its own user, and a dollar sign multiplying. None have a green checkmark. */}
For context on how managed platforms handle shared state, see [How to Use AI to Run Startup Operations with a 3-Person Team](/blog/how-to-use-ai-to-run-startup-operations-with-a-3-person-team).
---
## Step 4: Role-Based Permissions and Access Control for Team AI Agents
In a team, not everyone should have the same access.
- **The founder** might want the agent to deploy code and manage infrastructure
- **A marketer** should be able to research competitors but not push to production
- **An intern** should observe and learn, not run arbitrary shell commands
OpenClaw has no permission model. Every user who reaches the agent can:
- Execute shell commands on the server
- Access all connected integrations
- Read every conversation in history
- Use all configured API keys (and their spending limits)
Building RBAC into OpenClaw means intercepting every agent action and checking it against a permission matrix. Most teams that attempt this end up writing more auth code than feature code.
{/* GRAPHIC IDEA: Permission matrix table graphic. Rows: Founder, Engineer, Marketer, Intern. Columns: Run shell commands, Deploy code, Access integrations, Read all conversations, Manage API keys. OpenClaw column: all checkmarks for everyone (no control). Duet column: configurable per role with locks and checkmarks. Visual contrast between "everything is open" vs. "granular control." */}
---
## Step 5: Keeping Your Team OpenClaw Instance Running 24/7
A team agent that goes down at 2 AM and nobody notices until standup is worse than no agent at all.
### What You Need
- **Process management**: systemd or Docker's `--restart` policy
- **Health checks**: HTTP endpoint monitoring via UptimeRobot or Healthchecks.io
- **Alerting**: Slack/email notifications on failure
- **Log aggregation**: Centralized logging so you can debug without SSHing into the box
- **Backups**: Automated daily snapshots of workspace and config
- **Update strategy**: How do you update OpenClaw without losing state?
```plaintext
# Basic health check cron
*/5 * * * * curl -sf http://localhost:3000/health || \
(docker restart openclaw && \
curl -X POST https://hooks.slack.com/services/YOUR/WEBHOOK \
-d '{"text":"OpenClaw restarted automatically"}')
```
This gets you basic uptime. It does not get you zero-downtime updates, automatic scaling, or disaster recovery. For a deeper look at always-on configuration, see [How to Set Up a 24/7 AI Agent](/blog/how-to-set-up-a-24-7-ai-agent).
{/* GRAPHIC IDEA: "Iceberg" illustration. Above water (visible): "OpenClaw is running." Below water (hidden ops work): SSL renewal, Docker updates, dependency patching, log rotation, disk cleanup, API key rotation, backup verification, security audits, cost monitoring. Label: "The 90% of team hosting you don't see until something breaks." */}
---
## The Hidden Maintenance Cost of Self-Hosting OpenClaw for Teams
Even after setup, self-hosted team OpenClaw requires ongoing work:
Task | Frequency | Time
Docker/OS security patches | Weekly | 30 min
OpenClaw version updates | Bi-weekly | 1 hour
API key rotation | Monthly | 30 min
Backup verification | Monthly | 30 min
Disk cleanup and log rotation | Monthly | 30 min
Debugging integration breakages | As needed | 1 to 4 hours
Troubleshooting user access issues | As needed | 30 min to 2 hrs
**Conservative estimate: 4 to 8 hours per month of DevOps work** that has nothing to do with the work your team actually hired the AI agent to do.
Over a year, that is 48 to 96 hours of engineering time. At $100/hour: **$4,800 to $9,600 in hidden cost**, on top of the $5 to $20/month server bill.
### Year-One Cost Comparison: OpenClaw vs. Duet
Cost Category | OpenClaw (Team of 5) | Duet (Team of 5)
Setup labor | $3,000 (30 hrs) | $0
Server/hosting | $240 ($20/mo) | Included
Maintenance labor | $7,200 (6 hrs/mo) | $0
Monthly plan | $0 | From $20/mo
**Total Year One** | **$10,440** | **Depends on plan and reserve overage**
{/* GRAPHIC IDEA: Running cost calculator graphic. Two columns side by side. Left: "OpenClaw for Teams, Year 1 Cost." Setup: $3,000. Server: $240. Maintenance: $7,200. Total: $10,440. Right: "Duet." Setup: $0. Monthly plan: from $20. Maintenance: $0. Paid reserve covers overage. */}
---
## The Managed Alternative: How Duet Replaces All 5 Setup Steps
Everything described above (cloud hosting, multi-user auth, shared state, permissions, uptime, monitoring, updates) is built into Duet from day one.
### What Setup Looks Like on Duet
1. Go to [duet.so](/)
1. Sign up with Google or email
1. Invite your team
1. Start a session with the agent
That is it. No Docker. No VPS. No OAuth proxy. No forking repos to add user tracking.
{/* GRAPHIC IDEA: Side-by-side terminal screenshot comparison. Left: a wall of bash commands, docker configs, nginx files, and error output. Right: a clean Duet workspace with Sessions and Apps ready. Caption: "Same capability. 44 hours vs. 3 minutes." */}
### What You Get Out of the Box
Feature | OpenClaw (DIY) | Duet
**Cloud hosting** | You build it | Managed infrastructure
**Multi-user** | Custom auth layer needed | Built-in team workspaces
**Shared context** | Fork + database migration | Durable sessions, files, and shared history
**Permissions** | No RBAC, full access for all | Role-based access control
**24/7 operation** | Your responsibility | Managed cloud runtime
**Integrations** | 10,700+ skills (manual setup) | 10,000+ (one-click OAuth)
**Security** | DIY firewalls, key management | Dedicated workspace VM, scoped credentials
**Updates** | Manual Docker pulls | Managed releases
**Mobile access** | None (SSH only) | Responsive web workspace
**Audit logs** | Build your own | Built-in, searchable
**Setup time** | 24 to 44 hours | 3 minutes
{/* GRAPHIC IDEA: Feature checklist infographic. Two columns with feature names in the center, green checkmarks on Duet's side, red X or yellow warning icons on OpenClaw's side. Visual emphasis on the number of things that "just work" on Duet vs. require engineering on OpenClaw. */}
To understand how Duet compares more broadly, see [Duet vs OpenClaw](/guides/duet-vs-openclaw) and [OpenClaw vs Managed AI Agent Platforms](/blog/openclaw-vs-managed-ai-agent-platforms).
---
## How Real Teams Use Duet Instead of Self-Hosted OpenClaw
Once the infrastructure question is off the table, teams focus on what matters: getting work done with AI.
### Shared Sessions
Your team assigns work to the AI agent in durable sessions. When the marketing lead asks the agent to research competitors, teammates can follow the session events and inspect the resulting files. When an engineer asks it to review a PR, the work history remains available in that session for later reference.
{/* GRAPHIC IDEA: Screenshot-style mockup of a Duet session timeline. Show Sarah assigning a competitor-pricing analysis, Duet returning structured data, and James following up in the same durable session. Highlight: "Shared context. Durable work history." */}
### Agent That Never Sleeps
Schedule tasks, trigger workflows, and let the agent handle background work while your laptop stays closed. Morning standup summaries, nightly data pulls, automated report generation. All running on Duet's cloud infrastructure without any server maintenance.
{/* GRAPHIC IDEA: 24-hour clock visualization. Different segments of the day labeled with agent activities: "6 AM: Pull overnight metrics." "9 AM: Generate standup summary." "12 PM: Monitor competitor pricing." "3 PM: Draft weekly report." "11 PM: Run scheduled backups." Center text: "Your agent works the hours you don't." */}
### One-Click Integrations
Connect GitHub, Slack, Notion, Google Workspace, Linear, and thousands more with OAuth. No API key juggling. No `.env` files. No debugging broken integrations after every update.
In Duet, Integrations connect external services. Reusable instructions belong in Files, while durable facts and sources belong in Train, so the same guidance and context can be used across Sessions without installing a catalog item.
{/* GRAPHIC IDEA: Integration grid with logos of popular tools (GitHub, Slack, Notion, Google Drive, Linear, Jira, Figma, HubSpot, Salesforce) arranged in a clean grid. Each has a green "Connected" badge. Below: "10,000+ integrations. Zero configuration files." */}
---
## Self-Host OpenClaw vs. Use Duet: How to Decide for Your Team
### Self-host OpenClaw if:
- You are a **solo developer** who wants full control
- You need to run models **on-premises** for regulatory reasons
- You enjoy infrastructure work and treat it as a learning exercise
- Your budget is under $50/month and your time is free
### Use Duet if:
- You are a **team of 2 or more** who need shared AI
- You want your agent **always on**, not just when your laptop is open
- You would rather spend engineering hours on product, not DevOps
- You need **permissions, audit logs, and compliance** without building them
- You want **mobile access** to your agent
{/* GRAPHIC IDEA: Decision tree flowchart. Start: "How many people need access?" If "Just me," then "Do you enjoy server admin?" If yes: "OpenClaw." If no: "Duet." If "2+ people": "Duet." Clean, simple, three paths. */}
---
## How to Migrate Your Team from OpenClaw to Duet
Already running OpenClaw and ready to stop maintaining infrastructure? Migration is straightforward.
1. **Export your workspace**: `tar -czf backup.tar.gz ~/.openclaw/workspace`
1. **Sign up for Duet** at [duet.so](/)
1. **Reconnect integrations** via OAuth (one click each)
1. **Move reusable instructions into Files** and add durable facts or sources through Train
1. **Invite your team** and start collaborating in Sessions
Your conversation history stays in OpenClaw's archive. New work happens in Duet Sessions with team visibility from day one.
{/* GRAPHIC IDEA: Migration flow diagram. Three steps in a left-to-right layout: "OpenClaw (local)" then "Export workspace" then "Duet (cloud)" with team member avatars joining the Duet side. Simple, clean, visual. */}
---
## Frequently Asked Questions
### Is OpenClaw free for teams?
The software is free. The infrastructure, engineering time, and ongoing maintenance are not. For a team of 5, expect $10,000 or more in first-year costs when you factor in setup and maintenance labor. The platform itself costs nothing, but cloud hosting runs $5 to $60/month and engineering time for multi-user configuration totals 24 to 44 hours.
### Can I use OpenClaw skills on Duet?
OpenClaw skills are not installed directly in Duet. You can adapt their reusable instructions into Files, put durable facts and sources in Train, reconnect supported services through Integrations, and run the resulting work in Sessions. If the workflow produces a web tool, Duet can keep it available under Apps.
### How much does Duet cost for a team?
Duet offers Starter, Pro, and Max monthly plans with included credits. The designated payer manages methods, paid-reserve topups, limits, and history in user settings; compare the current plans with the infrastructure and engineering time required to operate OpenClaw yourself.
### Is my data safe on Duet?
Duet runs agents in isolated sandboxes with encrypted credential storage and network isolation. Your API keys are stored in an encrypted vault, not plain-text `.env` files on a VPS. Each workspace is isolated from other organizations.
### What if I need on-premises hosting?
If regulatory requirements mandate on-premises infrastructure, OpenClaw is the right choice. Duet is cloud-hosted. For most teams, Duet's security model (isolated sandboxes, encrypted storage, SOC 2 practices) meets or exceeds what a self-managed OpenClaw deployment provides.
### How long does it take to set up OpenClaw for a team?
Expect 24 to 44 hours of engineering time for initial setup, spread across cloud hosting (2 to 4 hours), authentication (8 to 16 hours), shared state (4 to 8 hours), permissions (8 to 12 hours), and monitoring (2 to 4 hours). After that, budget 4 to 8 hours per month for ongoing maintenance.
### Can multiple people use the same OpenClaw instance at the same time?
OpenClaw's default setup is single-user. Multiple people accessing the same instance share all conversations, integrations, and API keys without any isolation. There is no built-in way to track who asked what or restrict what each user can do. For team use, you need to build custom authentication and authorization layers on top.
### What is the best AI agent platform for teams in 2026?
For teams that want shared AI agents with built-in collaboration, managed platforms like Duet are the most practical choice. They provide multi-user workspaces, role-based permissions, 24/7 uptime, and pre-configured integrations without any infrastructure work. OpenClaw remains the best option for solo technical users who want maximum control and customization.
---
## The Verdict: OpenClaw Team Setup vs. Duet for Teams in 2026
OpenClaw is an exceptional tool for individual power users. But making it work for a team means building a platform on top of a platform: auth, permissions, shared state, monitoring, uptime, and security. That is 24 to 44 hours of setup and 4 to 8 hours per month of maintenance.
Duet ships all of that on day one. Your team signs up, invites members, and starts working with a shared AI agent in minutes. No servers. No Docker. No custom auth layers. No 3 AM pager alerts because the container ran out of memory.
The question is not whether OpenClaw _can_ work for teams. It is whether building that infrastructure is the best use of your team's time.
[Get started with Duet](/)
### What is OpenClaw and what does it do?
OpenClaw is an open-source AI agent platform that runs locally on your machine. It connects AI models (like Claude) to your files, tools, and workflows, letting you build and run persistent AI agents without sending data to a third-party cloud. It's designed for developers and teams who want full control over their AI agent infrastructure.
### How do you install OpenClaw for a team?
OpenClaw is installed via npm on each team member's machine. After installation, you configure it with your preferred AI provider API key and set up a shared workspace or individual workspaces per user. Team setups typically involve sharing agent configuration files and skill libraries via a git repository.
### What's the difference between OpenClaw and Duet for teams?
OpenClaw runs locally on each person's machine - great for individual power users who want privacy and control. Duet is a cloud-hosted platform where agents run persistently in shared team workspaces. OpenClaw is free and self-managed; Duet adds collaboration features, always-on execution, and managed infrastructure.
### Can OpenClaw connect to external tools and APIs?
Yes. OpenClaw supports MCP (Model Context Protocol) servers, which let agents connect to external tools, databases, and APIs. You can also write custom skills - reusable agent capabilities that extend what OpenClaw can do. Common integrations include GitHub, Notion, Slack, and custom internal APIs.
### Is OpenClaw suitable for non-technical team members?
OpenClaw is primarily built for developers - setup requires terminal access and basic configuration. Non-technical team members can use agent outputs and shared workflows, but they're unlikely to set up or maintain OpenClaw themselves. For mixed teams, a managed platform like Duet is often a better fit.
### How do you share agent skills across a team using OpenClaw?
The standard approach is to store skill files in a shared git repository that all team members clone. When a skill is updated, team members pull the latest version. OpenClaw's workspace structure makes it straightforward to version-control and distribute agent capabilities.
---
Source: https://duet.so/install
# Duet agent install
Purpose: connect this coding agent to Duet, an API-first shared cloud drive. One Duet workspace maps to one always-on VM. The VM disk is the drive and source of truth. Agents use duet for files, memory, workspaces, and sign-in; MCP clients use the hosted Streamable HTTP server.
There are two front doors and they are equal. Pick the one that matches the human you are working with:
- Door A, device pairing: they can open a browser, and approve a code you show them.
- Door B, email sign-in: they can read their email, and read a code back to you out of it.
Both doors return a human identity key, saved at `~/.duet/config.json`, mode 0600. Current membership and role determine workspace access. The same saved login works for CLI commands and Mac sync. Then run the shared MCP step once.
Never print the key. Keep it out of transcripts, logs and source. Manage it at https://app.duet.so/settings/api-keys or through the user API-key endpoints.
## Sign in: pick a door
First the CLI, which both doors end up using — door A signs in with it, door B checks its key with it:
```sh
# Bun 1.3.14 and Node 22+ required.
# Install on your own computer.
# Duet VMs include the command.
npm i -g @duetso/agent
```
Then take one of the two doors below. One of them, not both.
### Door A: device pairing
Take this one when your human can open a browser: they approve a code you show them.
```sh
# 1. Start device pairing. A human must approve the displayed code in the browser.
duet --api-url https://ctl.duet.so login
# 2. Inspect your current workspaces and roles. The key stays in ~/.duet/config.json.
duet whoami
```
Expected behavior:
- `duet login` prints a user code and a verification URL.
- The human opens that URL and approves the code.
- The CLI polls until approval, then writes `~/.duet/config.json` with mode 0600.
### Door B: email sign-in
Take this one when your human can read their email: Duet mails them an eight-character code, they read it back to you, and you exchange it for the key.
```sh
# 1. Mail a sign-in code to your human's address, keeping the 202's request_id.
DUET_API_URL="https://ctl.duet.so"
DUET_REQUEST_ID=$(curl -fsS -X POST \
"$DUET_API_URL/v1/auth/email/start" \
-H 'content-type: application/json' \
-d '{
"email":"human@example.com",
"client_name":"Claude Code"
}' \
| node -pe 'JSON.parse(
require("fs").readFileSync(
0, "utf8",
),
).request_id')
export DUET_REQUEST_ID
# 2. Exchange the code your human read back. Same shell as step 1, whose export it reads.
DUET_API_URL="https://ctl.duet.so" DUET_CODE="" \
node --input-type=module <<'NODE'
import {
chmodSync, existsSync, mkdirSync,
readFileSync, writeFileSync,
} from "node:fs";
import { join } from "node:path";
const {
DUET_API_URL: apiUrl,
DUET_REQUEST_ID, DUET_CODE,
} = process.env;
const response = await fetch(
`${apiUrl}/v1/auth/email/verify`, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({
request_id: DUET_REQUEST_ID,
code: DUET_CODE,
}),
});
const body = await response.json();
if (!response.ok) throw new Error(`${response.status} ${JSON.stringify(body)}`);
const duetDir = join(process.env.HOME, ".duet");
mkdirSync(duetDir, { recursive: true, mode: 0o700 });
const outPath = join(duetDir, "config.json");
const config = existsSync(outPath)
? JSON.parse(readFileSync(
outPath, "utf8",
))
: {};
Object.assign(config, {
apiKey: body.access_token,
defaultWorkspace:
body.workspace.slug,
apiUrl,
});
writeFileSync(
outPath,
JSON.stringify(config, null, 2)
+ "\n",
{ mode: 0o600 },
);
chmodSync(outPath, 0o600);
console.log(`Signed in to ${body.workspace.slug}. Wrote ${outPath}; key not printed.`);
NODE
# 3. Inspect your current workspaces and roles.
duet whoami
```
Expected behavior:
- `POST /v1/auth/email/start` answers 202 with `{"request_id":"req_…","expires_in":600}`. The answer is byte-identical whether or not that address already has an account: it proves possession of the mailbox and says nothing about who owns it.
- The code is `XXXX-XXXX`, upper-case letters and digits, read by a human out of an email Duet sent them.
- `POST /v1/auth/email/verify` settles the account and the workspace, and answers with `access_token`, `prefix`, `scopes`, `workspace`, and `created`.
- On a first sign-up, add `name` and `workspace_name` to the verify body. For a human who already has a workspace both are ignored, and nothing is renamed.
- `409 workspace_ambiguous` lists the workspaces they belong to and does not consume the code. Ask which one, then call verify again with the same code plus `workspace_slug`.
- `400 invalid_code` carries `attempts_remaining`; `410 expired` means start over from `start`; a 429 carries `retryAfterSeconds`.
## Connect MCP, from whichever door you took
```sh
# Prepare a local MCP config without printing the bearer token.
DUET_MCP_PUBLIC_URL="https://mcp.duet.so" node <<'NODE'
const fs = require("node:fs");
const path = require("node:path");
const duetDir = path.join(process.env.HOME, ".duet");
const cfg = JSON.parse(
fs.readFileSync(
path.join(duetDir, "config.json"),
"utf8",
),
);
if (typeof cfg.apiKey !== "string" || cfg.apiKey.length === 0) throw new Error("Sign in first.");
const outPath = path.join(duetDir, "mcp.json");
fs.writeFileSync(
outPath,
JSON.stringify(
{
name: "duet",
transport: "streamable-http",
url: process.env.DUET_MCP_PUBLIC_URL,
headers: { authorization: `Bearer ${cfg.apiKey}` },
},
null,
2,
) + "\n",
{ mode: 0o600 },
);
fs.chmodSync(outPath, 0o600);
console.log(`Wrote ${outPath}. Import it into your MCP client; bearer token not printed.`);
NODE
```
MCP connection details:
- URL: https://mcp.duet.so
- Transport: Streamable HTTP
- Header: Authorization: Bearer
- Local config helper: the block above writes `~/.duet/mcp.json` with mode 0600 and does not print the bearer token.
Useful checks after either door:
```sh
duet whoami
duet workspace ls --json
```
## Choose an operation target
A workspace is an operation target, not a different login. Choose a default for remote commands with `duet workspace use `, or pass an explicit workspace address such as `demo:/notes.txt`.
Local prompts, memory and training stay local. Add `--workspace ` to memory or training to run the remote operation; a saved default does not change execution mode.
```sh
duet memory recall "project notes" --workspace demo
duet sync install
```
Mac sync uses the same saved login and a separate non-secret computer identity. Its engine ships for both supported Mac architectures; it mirrors workspaces where your current role permits writing.
---
Source: https://duet.so/pricing
# Pricing
A plan for the work you're ready to hand off.
Take 7 days free, then choose the monthly plan that fits. Credits reset each period; your paid reserve keeps overage moving.
## Monthly plans
- **starter** — $20/month, with a 0% credit bonus.
- **pro** — $50/month, with a 20% credit bonus.
- **max** — $200/month, with a 25% credit bonus.
## Model tiers
You pick a quality level, not a model name. Duet routes each task to the strongest model for it and the rate is flat whichever model answers.
- **Max** — Automatically routes each task to frontier models from OpenAI, Anthropic, and open source providers for the strongest results.
- **Standard** — Automatically routes each task to leading models from OpenAI, Anthropic, and open source providers, balancing quality, speed, and cost.
- **Economy** — Low-cost models from OpenAI, Anthropic, and open source providers for scheduled maintenance work. Not recommended as your main model.
Every plan starts with a 7-day free trial and no card. Credits reset each period.
---
Source: https://duet.so/privacy-policy
# Privacy Policy
What data Duet collects, how it is used, and the choices you have over it.
The controlling text is the page itself — it is a legal document, and a summary of it is not the agreement. Read it in full at the URL above, or write to team@duet.so with questions.
---
Source: https://duet.so/terms
# Terms of Service
The contract governing use of Duet, including acceptable use, billing, and termination.
The controlling text is the page itself — it is a legal document, and a summary of it is not the agreement. Read it in full at the URL above, or write to team@duet.so with questions.
---
Source: https://duet.so/use-cases
# Duet by role
## Roles
- [Small business owners](https://duet.so/use-cases/small-businesses.md): Duet is an always-on AI for small business owners. Build a website, run support, onboard customers, and ship internal tools — without hiring another role.
- [Creative agencies](https://duet.so/use-cases/agencies.md): Duet is AI for creative agencies. Ship landing pages, draft concepts, generate on-brand imagery, and package deliverables faster — without growing headcount.
- [Startup founders](https://duet.so/use-cases/founders.md): Duet is AI for startup founders — the cofounder you can deploy. Build a working MVP, run research, draft fundraising decks, and send investor updates.
- [Sales teams](https://duet.so/use-cases/sales-teams.md): Duet is AI for sales teams that closes the admin gap. Enrich inbound, run outbound, keep the CRM clean, and follow up — so reps sell instead of copy-paste.
- [Operations teams](https://duet.so/use-cases/operations.md): Duet is AI for operations teams. Schedule meetings, automate documents, ship recurring reports, and triage tickets so ops fixes the system, not firefights.
---
Source: https://duet.so/use-cases/agencies
# Duet for creative agencies
Stop losing margin to grunt work. Duet is AI for creative agencies that want to ship more per client without growing headcount — it builds the landing site, drafts the design concept, generates the on-brand imagery, and packages the deliverable, so your team gets back to the high-priced thinking the work was sold on.
An AI coworker for agencies is a persistent, cloud-based AI teammate that handles the production work a billable team usually grinds through — first drafts, on-brand imagery, deliverable assembly, client recaps, and reporting. It lives in one workspace per client or retainer, remembers context across engagements, and ships the repeatable pieces under your review rules so creative directors get back to the high-priced thinking the work was sold on.
## What it does
### Build client landing pages and microsites
Ask it: "Build a launch landing page for the Northbeam Series B campaign. Use the brand kit in /brand/northbeam. Hero, feature row, customer quote, signup form. Deploy to staging."
Outcome: A working build, not a stalled sprint
### Draft design concepts and creative briefs
Ask it: "Take the Loft 32 brief and draft 3 concept directions: positioning, key visual idea, sample tagline, and a 2-paragraph rationale for each."
Outcome: Multiple directions from one brief
### Generate on-brand imagery at scale
Ask it: "Generate 12 hero images for the Loft 32 site in the same style as /brand/loft32/refs — overhead studio shot, soft daylight, neutral palette."
Outcome: On-brand variants from your references
### Package and ship client deliverables
Ask it: "Zip the final assets in /clients/loft32/v3, write a handoff doc summarizing changes since v2, upload to the client Drive, and email the link to ben@loft32.com."
Outcome: Handoff done in one prompt
## The problems it picks up
### Production eats the margin
""We sold the strategy. We're delivering the slides.""
Duet handles the production layer — slides, decks, landing pages, image generation — so senior time stops getting burned on assembly. Your strategists go back to telling the story; Duet does the layout, the resizes, and the eighteenth round of asset renames.
### Concepts take too long to mock
""Three rounds of comps before the client says anything useful.""
Duet drafts the concept in your brand voice, generates the imagery in your visual language, and gets a review-ready first round in front of the client. The next round comes back faster too, because the working files live in your workspace — not on a designer's laptop you can't get to until Tuesday.
### Deliverables packaged by hand
""Friday is always the day we zip the assets and write the handoff doc.""
Duet bundles the final assets, writes the handoff doc, drops it in the client folder, and emails the link. No more Friday afternoons lost to file plumbing — the same workflow runs for every project, named the same way, with the same change log every time.
## Before and after
### Without Duet
- Senior strategists doing slide-cleanup at 9pm.
- Long gaps between brief and first concept review.
- Brand assets recreated from scratch every project.
- Friday handoffs done by hand in Dropbox.
### With Duet
- Production runs on Duet. Senior time goes to thinking and presenting.
- Concepts drafted from the brief, ready for human polish.
- A brand-aware AI that remembers every client's visual system.
- Handoffs packaged, named, and queued for review.
## How it works
1. **Load the brand** — Drop each client's brand kit, voice guidelines, and asset library into Duet. It learns the rules so the output looks like the brand on the first pass — and the second project for the same client starts from where the first one ended, not from a blank canvas.
2. **Brief like you brief a junior** — Hand Duet the brief in the same words you'd use with a new designer. It comes back with mocks, copy, and decks — all in your house style — and your senior people spend their time reviewing tasteful options instead of dictating layouts to a queue of contractors.
3. **Review and ship** — Polish the parts that matter, queue the rest. Duet packages deliverables, uploads to the client folder, writes the handoff note, and prepares the email. The Friday-afternoon ritual becomes a reviewable handoff instead of a manual scramble.
## FAQ
### Will the output actually look on-brand?
Yes — once Duet has the brand kit and a handful of reference outputs. The more you correct it in the first project, the closer it gets to your house style on the next one. Agencies use that review loop to turn rough first drafts into reusable client-specific style memory.
### Can we keep clients separated?
Each client gets its own workspace with isolated memory and files. Brand assets, drafts, and workspace history for one account never leak into another, and you can hand keys to a client (or revoke them) without that touching the other accounts you're running.
### Does Duet replace designers and copywriters?
No. It absorbs the production layer — the parts your senior people resent doing. Concepts still need taste, presentations still need a human in the room. Duet just clears the runway so the senior bench spends time on the work clients actually paid for.
### How do we bill for work Duet does?
The way you already do — by project, by deliverable, or by retainer. Duet is a cost line, not a billable role. The goal is to protect strategy pricing while reducing repetitive production time that eats margin.
### What about image generation rights?
Duet routes image work through commercial-use-capable providers where available, and your client data stays scoped to the workspace. For client deliverables, review the selected model/provider terms and pin or exclude providers when an account has specific IP requirements.
### How does Duet fit into a Figma / Adobe / Webflow stack?
Duet doesn't replace your design tools — it sits one step earlier, drafting the concept, the copy, and the visual references that feed into them. Hand it a brief, get a Figma-ready mock; hand it a wireframe, get a working Webflow page. Agencies use Duet to skip the blank-page pass on each project.
---
Source: https://duet.so/use-cases/by-job
# Duet by job
## Jobs
- [Customer support](https://duet.so/use-cases/by-job/customer-support.md): Duet drafts, triages, escalates, and prepares support replies for review, keeping routine tickets moving under your approval rules.
- [Sales & outbound](https://duet.so/use-cases/by-job/sales-outbound.md): Duet finds prospects, enriches leads, drafts first touches, follows up, and logs replies from one AI coworker workspace.
- [Inbox triage](https://duet.so/use-cases/by-job/inbox-triage.md): Duet triages shared inboxes, summarizes the day, drafts replies in your voice, flags urgent threads, and follows your approval rules.
- [Content marketing](https://duet.so/use-cases/by-job/content-marketing.md): Duet researches topics, drafts posts in your voice, schedules channels, repurposes wins, and reports back on what worked.
- [Bookkeeping](https://duet.so/use-cases/by-job/bookkeeping.md): Duet runs bookkeeping ops for lean teams — categorizes transactions, reconciles accounts, flags anomalies, and sends clean monthly reports.
- [SEO operations](https://duet.so/use-cases/by-job/seo.md): Duet runs SEO operations for lean teams — audits pages, finds keyword gaps, updates internal links, monitors rankings, and reports what changed.
- [Newsletter operations](https://duet.so/use-cases/by-job/newsletter.md): Duet gathers updates, drafts newsletters in your voice, prepares broadcasts for approval, and reports what worked after each campaign.
- [Invoicing & collections](https://duet.so/use-cases/by-job/invoicing.md): Duet drafts invoices, prepares reminders, follows up behind approval rules, reconciles payments, and flags overdue accounts.
- [Client onboarding](https://duet.so/use-cases/by-job/client-onboarding.md): Duet runs client onboarding — kickoff emails, intake forms, workspace setup, calendar booking, asset collection, and first-week follow-up.
- [Internal reporting](https://duet.so/use-cases/by-job/reporting.md): Duet runs internal reporting — pulls metrics, explains changes, builds daily or weekly briefs, and sends the next actions to your team.
- [Document handling](https://duet.so/use-cases/by-job/documents.md): Duet handles business documents — extracts terms, summarizes contracts, flags risks, renames files, routes approvals, and keeps records organized.
- [App building](https://duet.so/use-cases/by-job/app-building.md): Duet builds and runs small business apps — dashboards, portals, calculators, forms, automations, and internal tools hosted from your workspace.
---
Source: https://duet.so/use-cases/by-job/app-building
# Build small business apps with an AI coworker
Small businesses often have tiny apps they need and zero reason to hire a full engineering team: a quote calculator, client portal, invoice tracker, intake form, KPI dashboard, approval queue. Duet builds the app and runs it from the same workspace, so the tool does not become another thing you have to operate.
## The workflow
1. **Describe the job the app should do** — Tell Duet the workflow in plain English: who uses it, what they enter, what happens next, and what systems it should touch. The app starts from the business process, not from a framework choice.
2. **Connect the data sources** — Duet can connect spreadsheets, CRMs, payment tools, calendars, databases, files, or APIs through available integrations, credentials, or scoped setup. If the first version can run on a spreadsheet, Duet starts there instead of overbuilding.
3. **Generate the first working version** — Duet builds the UI, database, permissions, and workflow logic, then gives you a live URL. You test it with real data instead of reading a spec for two weeks.
4. **Iterate with the people who will use it** — Ask for changes in the same session: add a filter, rename a field, export CSV, make the mobile view less cramped, send an email when status changes. Duet ships the edits and remembers why they were made.
5. **Host and monitor the app** — The app runs from your Duet workspace with logs, files, memory, scheduled jobs, and integrations nearby. Build and run stay together, which is the difference between a demo and a business tool.
6. **Turn repeated work into automation** — Once the app is stable, Duet adds the cron, webhook, approval step, or report that lets it run on schedule under your rules. The app becomes a coworker-operated workflow, not another dashboard to babysit.
## FAQ
### Is Duet a no-code app builder?
Not exactly. No-code builders give you blocks to assemble. Duet gives you an AI coworker with a workspace, filesystem, memory, code execution, and integrations. You describe the business job and it builds the tool.
### What kinds of apps are best for Duet?
Internal tools, client portals, calculators, dashboards, intake forms, approval queues, reporting apps, lightweight CRMs, and workflow tools are ideal. Duet is not trying to replace a full product engineering team for complex consumer software.
### Can non-technical users make changes?
Yes. You ask in plain English and Duet edits the app. Technical users can inspect code and logs, but small business owners do not need to learn a builder interface to change a field or ship a new flow.
### Where are the apps hosted?
Apps are hosted from the Duet workspace on a Duet subdomain or custom domain. The same workspace that built the app can run scheduled jobs, manage files, and connect to the tools the app needs.
### Can Duet maintain the app after launch?
Yes. That is the point. Duet can monitor logs, fix copy, add fields, update integrations, generate reports, and keep the app aligned with the workflow as your business changes.
### How is this different from hiring a developer for a small tool?
A developer can build the first version, but then every change becomes a ticket. Duet builds the first version and keeps operating beside it, so small improvements happen when the business asks for them.
---
Source: https://duet.so/use-cases/by-job/bookkeeping
# Run bookkeeping with an AI coworker
Bookkeeping should not eat the same founder hours every month. Duet connects to the tools you already use, categorizes transactions, reconciles the obvious matches, flags the weird ones, and gives you a clean monthly packet to review or send to your finance partner. You stay lean without letting the books drift.
## The workflow
1. **Connect your accounting stack** — Connect QuickBooks, Xero, Stripe, Plaid, Mercury, Ramp, or the CSV exports you already pull. Duet reads the chart of accounts, vendor history, customer names, and prior reconciliations before touching new transactions.
2. **Teach the categorization rules** — Explain the edge cases once: software goes to subscriptions, contractors go to cost of goods sold, client meals get split, founder reimbursements need receipts. Duet turns that into reusable rules instead of asking the same question every month.
3. **Categorize and match transactions** — New transactions are categorized against the rule set, matched to invoices or receipts, and marked with confidence. High-confidence items are queued for batch approval; low-confidence items get a short note explaining what Duet needs from you.
4. **Reconcile the easy accounts** — Duet compares bank, card, Stripe, and accounting balances, resolves obvious timing differences, and produces a reconciliation checklist. The goal is not to pretend accounting judgment disappeared — it is to turn human review into a focused check instead of a manual rebuild.
5. **Flag anomalies before they become urgent** — Duplicate subscriptions, unusual vendor spend, missing receipts, late deposits, uncategorized transfers, and margin swings get surfaced as exceptions. You see the handful of weird things, not every line item.
6. **Send the monthly packet** — At month end, Duet prepares a concise packet: P&L, cash movement, unresolved questions, anomalies, and the files your finance partner needs. The books become a running system, not a quarterly archaeology project.
## FAQ
### Does Duet replace my finance partner?
No. Duet does the repeatable bookkeeping ops so your finance partner can review cleaner work and focus on judgment, taxes, and advice. Small teams can use Duet to prepare the month-end packet while keeping a human reviewer for sign-off.
### Can it write directly into QuickBooks or Xero?
Duet can connect to QuickBooks or Xero through available APIs, exports, or custom wiring with scoped permissions. Start in review mode, then allow high-confidence categories to post under your rules only once the setup has proven itself.
### How does Duet handle weird transactions?
Anything below the confidence threshold becomes an exception with a short explanation and the source documents attached. Duet does not bury ambiguity inside a category; it asks the human once, remembers the answer, and applies the rule next time.
### Is this useful if I already have a bookkeeper?
Yes. Duet reduces the back-and-forth that makes bookkeeping expensive: receipt chasing, vendor explanations, export cleanup, and monthly packet prep. Your bookkeeper gets cleaner inputs and fewer mystery rows.
### What accounting tools does it support?
Duet can connect to accounting workflows through APIs, exports, Plaid-connected data, CSV, or custom wiring depending on the tool. For QuickBooks, Xero, Stripe, Mercury, Ramp, Brex, and bank data, scope access before enabling writes.
### Will Duet move money or approve payments?
Not by default. Duet can prepare invoices, categorize expenses, and draft payment reminders, but money movement stays behind explicit approval unless you set a narrow trusted rule for it.
---
Source: https://duet.so/use-cases/by-job/client-onboarding
# Onboard new clients with an AI coworker
Client onboarding is where lean teams either look premium or look improvised. Duet turns a signed deal into a clean kickoff: welcome email, intake form, shared workspace, calendar invite, asset checklist, and first-week follow-up. The client feels like you have a bigger team than you do.
## The workflow
1. **Trigger from a signed deal or payment** — Duet watches Stripe, HubSpot, Attio, Pipedrive, DocuSign, or a manual approval. When a deal closes, it starts the onboarding workflow with the client, plan, scope, and owner already attached.
2. **Send the kickoff email** — Duet drafts the welcome note in your voice, introduces the working rhythm, links the intake form, and explains exactly what happens next. No blank-page kickoff every time a client signs.
3. **Collect the right assets** — Brand files, logins, analytics access, audience notes, deadlines, legal constraints, invoice details — Duet asks for what this client needs, not a generic bloated intake form.
4. **Create the workspace and first tasks** — Duet creates the Notion, Linear, Asana, ClickUp, Google Drive, or Slack workspace from your template, fills in the client details, assigns owners, and opens the first-week tasks.
5. **Book kickoff and chase missing inputs** — Duet schedules the kickoff call, sends reminders, and follows up on missing assets without you becoming the project manager before the project even starts.
6. **Send the first-week status brief** — After the first week, Duet summarizes what was received, what is blocked, what shipped, and what the client needs to do next. The relationship starts with momentum instead of confusion.
## FAQ
### Can Duet customize onboarding by package or client type?
Yes. Different packages can trigger different forms, workspaces, kickoff agendas, and asset requests. A lightweight audit and a full retainer should not get the same onboarding flow.
### Which project tools can it set up?
Duet can set up project spaces through managed integrations, APIs, shared folders, CSV, or custom wiring depending on the tool. For Notion, Google Drive, Slack, Linear, Asana, ClickUp, Trello, Airtable, or client portals, scope the exact create/update permissions during setup.
### Will the client know an AI is coordinating onboarding?
Only if you want that to be explicit. Many teams use Duet behind the scenes to draft, create, and chase, while the messages still come from the business in a consistent voice.
### How does Duet avoid asking clients for things twice?
It stores what the client already provided, checks the workspace before preparing reminders, and only asks for missing items. The follow-up is specific: the logo is in, analytics access is still missing.
### Can it handle compliance or legal steps?
Yes, as a checklist and routing layer. Duet can collect documents, send the right forms, and escalate legal review, but it does not make legal judgments without a human owner.
### Is this only for agencies?
No. Agencies benefit immediately, but consultants, service businesses, software onboarding teams, and ops-heavy founders use the same pattern: trigger, collect, create workspace, follow up.
---
Source: https://duet.so/use-cases/by-job/content-marketing
# Run content marketing with an AI coworker
Many SMBs ship content like a side project — when somebody finally has time this quarter. Duet is an AI coworker that runs content like a function: researches what's working, drafts in your voice, schedules across channels, repurposes the wins, and reports back on what landed. The flywheel finally spins.
## The workflow
1. **Define the topics you want to own** — Tell Duet the three or four themes your business should rank for and the audiences you write to. It builds a topic map, maps each theme to the customer pains it solves, and pulls the keywords that match — no SEO consultant required.
2. **Research the angle worth writing** — For each topic, Duet pulls what already ranks, what AI overviews currently cite, and what the competitive content gets wrong. You get a one-page brief with a clear angle, a target keyword, an outline, and the three sources worth referencing.
3. **Draft the post in your voice** — Duet writes a long-form draft using your existing blog as the voice reference, with proper structure (clear section headings, FAQ block, lede paragraph) and SEO basics built in (meta title, description, JSON-LD). It's a real draft an editor can ship, not a first pass that needs to be rewritten.
4. **Prepare the CMS draft or PR** — WordPress, Webflow, Ghost, Sanity, Contentful, or Markdown to GitHub — Duet can prepare a CMS draft or PR through the integration path you enable, with social-share images ready for review. Internal-link suggestions land in the same PR / draft so the article ships with the link graph it needs.
5. **Repurpose across LinkedIn, X, and the newsletter** — Every long-form post becomes a LinkedIn carousel, an X thread, two replies into existing conversations, and a section of the next newsletter. Duet writes each variant to the channel's actual norms — not a single message reposted five times.
6. **Track what worked and double down** — Duet pulls GSC, Plausible, GA4, and the social platforms once a week, identifies the posts that picked up traffic or replies, and proposes the next three articles based on what readers are actually engaging with — not what looked clever in the brainstorm.
## FAQ
### Will the writing sound like AI slop?
Not if Duet has your blog and your social as voice references. The drafts pick up sentence rhythm, the way you transition between sections, your tic of using em-dashes or short paragraphs — the small choices that make a piece sound like a person, not a template. The editor pass is real editing, not rewriting from scratch.
### How do I make sure the SEO actually works?
Every draft ships with the basics Google now expects on a content piece: a real H1, semantic H2s, a structured FAQ block with FAQPage JSON-LD, internal links to relevant pages, and meta tags that match the body. Duet won't manufacture rankings on a stale keyword — it researches what's currently winning before drafting.
### Can it write for AI overviews / ChatGPT search / Perplexity, not just Google?
Yes. The brief step looks at what AI overviews already cite for the target query and writes the angle to be cited too — short summary up top, plain factual statements with citations, FAQ block with crisp answers. The same structure Google rewards is the structure AI search rewards, so you're not splitting effort across two strategies.
### Which CMSes can it prepare drafts for?
Duet can prepare CMS drafts, exports, or PRs through integrations, APIs, Git-based workflows, exports, or custom wiring depending on the CMS. For WordPress, Webflow, Ghost, Sanity, Contentful, Strapi, Notion, Hashnode, dev.to, or Markdown-to-GitHub workflows, scope draft/PR permissions before enabling any publishing path that writes live.
### How much content can it ship per week?
A sustainable SMB cadence is a focused long-form post plus repurposing into the channels your audience actually reads. You can increase volume later, but the wins come from compounding the same topic cluster, not from publishing more for its own sake.
### Does it replace a content marketer?
No. It handles the work nobody on the team has time to do. A content marketer designs the strategy, picks the topics, and reviews the drafts; Duet does the research, the drafting, the publishing, and the repurposing. The marketer's output goes from one post a month to a content function that runs on a calendar.
---
Source: https://duet.so/use-cases/by-job/customer-support
# Hand customer support to an AI coworker
Customer support is where small businesses bleed time. Duet is an AI coworker that drafts, triages, escalates, and prepares replies for review, then keeps routine tickets moving under your approval rules. The inbox is prepared before you sit down in the morning — not a graveyard by Friday.
## The workflow
1. **Connect your support inbox and help docs** — Point Duet at support@ (Gmail, Help Scout, Gorgias, Zendesk, Intercom, or plain IMAP) and at your help center, FAQ pages, and refund policy. Duet ingests recent tickets and your knowledge base so its first reply already sounds like you.
2. **Teach it your voice with the real replies** — Drop in real replies you sent — the messy ones, the long ones, the short ones — so Duet learns tone, signature, default refund stance, and the phrases you use when something has gone wrong. The rest of the playbook inherits from those examples.
3. **Set the escalation rules** — Tell Duet what you want to see yourself: high-value refund requests, churn risk, anything mentioning a lawyer, anything from a strategic customer. Everything else is drafted into send-as-is or review queues based on your confidence threshold.
4. **Let it triage every new ticket** — New tickets land, Duet classifies them in seconds, drafts a reply, attaches the relevant help-doc link, and tags the ticket. You see a clean queue with three buckets: send-as-is, edit-and-send, and needs-me.
5. **Prepare approved responses for easy ones** — Password resets, order-status checks, invoice copies, refund acknowledgments — Duet prepares or routes responses through the connected helpdesk after approval or under explicit rules, logs the action, and keeps the ticket moving. The customer gets a fast, useful answer instead of waiting for a Monday-morning reply.
6. **Get a recurring support brief** — On a weekly cadence, Duet drops a one-paragraph brief in your inbox: tickets handled, top three themes, anything escalated waiting on you, and what changed about your customers' questions this week.
## FAQ
### Will it actually sound like me, or will customers spot the bot?
Duet reads approved examples of your recent replies inside your workspace, so it can use your sign-off, your apologies, your refund stance, and the specific phrases you use when something has gone wrong as context. The goal is for routine replies to sound close enough that the first review pass is about small corrections, not rewriting from scratch.
### What happens when a customer is angry or the ticket is sensitive?
You set the escalation rules. Refund requests over a threshold, churn risk, anything mentioning legal action, anything from a top customer — Duet flags them, drafts an empathetic holding reply, and routes the ticket to the queue you watch yourself. The risky ones never get sent without you.
### Which inboxes and helpdesks does it work with?
Duet can connect to inboxes and helpdesks through managed integrations, APIs, IMAP, CSV, or custom wiring depending on the vendor. For Gmail, Outlook, Help Scout, Gorgias, Zendesk, Intercom, Front, Freshdesk, and Crisp-style workflows, scope the exact read, draft, and write-back permissions during setup.
### How long until tickets are actually being handled, not just drafted?
Teams should move from drafted-for-review to explicitly enabled sends category by category. The safest path is to start with one well-defined bucket — order status or password resets — enable narrow send rules once the drafts look right, then expand from there.
### What does it cost compared to a support agent or a helpdesk add-on?
A part-time support contractor and helpdesk AI add-ons can both become meaningful line items. Duet offers monthly plans with included credits and a paid reserve for overage; compare the current plan with your ticket volume.
### Does Duet replace my support team?
No. Duet handles the repeatable volume so your team can focus on conversations that actually need a human. Status checks, resets, and refund acknowledgments can move out of the queue; judgment-heavy tickets land on a human's desk faster, with more context, and without a backlog in front of them.
---
Source: https://duet.so/use-cases/by-job/documents
# Handle business documents with an AI coworker
Every small business has a document graveyard: contracts, invoices, PDFs, decks, receipts, forms, statements. Duet reads them, extracts the useful fields, flags the risky parts, files them where they belong, and turns the pile into a system. No enterprise document platform required.
## The workflow
1. **Connect the places documents land** — Duet watches Gmail, Google Drive, Dropbox, Notion, Slack uploads, and shared folders. It can also process one-off PDFs, scans, images, and Word docs you add to Files.
2. **Extract the fields that matter** — For invoices, contracts, receipts, statements, and forms, Duet extracts names, dates, amounts, renewal terms, payment terms, obligations, and owners into a table or CRM record.
3. **Summarize and flag risk** — Duet summarizes the document in plain English and flags unusual clauses, missing signatures, auto-renewals, late fees, mismatched totals, or anything that should go to a human before approval.
4. **Rename and file with routing rules** — Files get renamed with a consistent pattern and routed to the right folder or record. You stop searching for “final_final_contract_signed_v3.pdf” and start opening the client record.
5. **Route approvals and reminders** — Duet pings the right owner for approval, follows up before renewal dates, and creates tasks for documents that need signatures or missing attachments. The document becomes a workflow, not a dead file.
6. **Build a searchable business memory** — The extracted fields and summaries live in Duet memory, so future questions like “which vendors renew in June?” or “what did this client agree to?” get answered without opening a folder maze.
## FAQ
### Can Duet read scanned PDFs and images?
Yes. Duet can OCR scanned PDFs and images, then extract structured fields and summarize the document. Low-confidence OCR gets flagged instead of treated as truth.
### Is this legal review?
No. Duet can summarize terms, flag unusual clauses, and prepare questions for counsel, but it is not a lawyer. Legal approval stays with a human.
### Can it organize Google Drive?
Yes. Duet can rename files, create folders, move documents, attach them to CRM or project records, and keep a log of what changed.
### What document types work best?
Contracts, invoices, receipts, bank statements, vendor forms, client briefs, onboarding docs, tax packets, PDFs, images, Word docs, and decks all work well when the fields to extract are clear.
### How does Duet avoid leaking sensitive documents?
Each workspace runs on its own isolated cloud server, and document outputs stay inside that workspace unless you explicitly share or export them. You can also keep approval required before anything leaves the system.
### Can it build a searchable archive from old documents?
Yes. Duet can process a folder of old documents, extract metadata, write summaries, and create an index so the archive becomes searchable business memory instead of storage clutter.
---
Source: https://duet.so/use-cases/by-job/inbox-triage
# Triage your inbox with an AI coworker
You don't have an email problem — you have an attention problem dressed as an email problem. Duet is an AI coworker that reads new messages on a schedule, drafts replies in your voice, flags the ones that actually need you, and clears the rest. The inbox is prepared before review.
## The workflow
1. **Connect your inbox** — Gmail, Outlook, or plain IMAP. Duet authenticates via OAuth, reads recent messages, and uses the sender and thread patterns you approve to separate urgent conversations from noise.
2. **Teach it your priorities in plain English** — "Customers always, vendors next, newsletters low priority, billing urgent." One paragraph is enough; Duet turns it into the rule set that decides what lands on your desk and what does not.
3. **Schedule the overnight pass** — While you sleep, Duet reads every new thread, drafts replies for the ones that need them, labels likely noise for batch review, and labels the rest by intent — sales, support, billing, recruiting, personal — using the same buckets your real workflow already runs on.
4. **Wake up to a triaged queue, not an unread pile** — Your inbox opens to three things: a one-paragraph brief at the top, a small "needs you" list, and a folder of drafted replies waiting for a single approval click. Everything else is queued, labeled, or prepared for review under your rules.
5. **Approve drafts in a single sweep** — Click through the drafts queue — accept, edit, reject. Duet remembers every edit so the next batch needs less correction, and the rejections train the rules so it stops drafting the kinds of replies you don't actually want sent.
6. **Get a Friday-afternoon recap** — On a weekly cadence, Duet sends a recap: top senders this week, what changed (more recruiter spam, fewer customer questions), threads you marked important but never replied to, and the open loops worth closing before Monday.
## FAQ
### Is it safe to give an AI access to my inbox?
Duet authenticates through standard OAuth — the same flow Gmail and Outlook use for any third-party app — and runs in its own private cloud server, not a shared model. Your messages aren't training a foundation model and aren't pooled with other customers' data. The audit log shows every read, draft, and send so you can see exactly what Duet has touched.
### What if it drafts the wrong reply on a sensitive thread?
You set the rule. By default, anything you mark as personal, anything involving money over a threshold, and anything tagged "sensitive" gets a draft but never an automatic send — the reply waits for you. As you train it on your edits, you can raise the confidence threshold for explicitly enabled send categories while keeping it low on risky ones.
### How is this different from Gmail's built-in smart reply?
Smart reply suggests three short sentences; Duet writes the whole reply, references the thread context, references prior threads with the same person, and decides whether to draft, escalate, or use an explicitly enabled send rule. The job isn't to suggest one sentence faster — it's to make the inbox need you less for repeatable work.
### Can my whole team use this on a shared inbox like support@ or sales@?
Yes. Duet runs on shared inboxes the same way it runs on personal ones — reads, drafts, escalates, and follows the send rules you explicitly enable — and you can set the rules per inbox. A common setup is support@ with narrow approval rules for easy categories and sales@ in draft-and-review mode while the team is still learning what Duet's first touches read like.
### How much email volume is too much for Duet?
Duet is designed for high-volume inbox triage because the heavy lifting — classification and drafting — runs on the same sandbox infrastructure that powers the rest of the workspace. In practice, approval policy and review capacity are often the bottlenecks to plan around.
### Does it work in languages other than English?
Yes. Duet drafts replies in the language the original message used, and you can set per-rule language preferences ("reply to French customers in French, everything else in English"). The triage classifier is multilingual; the drafts inherit the tone of your past replies in that language.
---
Source: https://duet.so/use-cases/by-job/invoicing
# Run invoicing and collections with an AI coworker
Getting paid should not depend on the founder remembering to prepare a polite nudge. Duet drafts invoices from the work already done, prepares them in your accounting tool, follows up behind your approval rules, reconciles payments, and flags the accounts that need judgment. Cash collection becomes a system, not a mood.
## The workflow
1. **Connect billing, contracts, and project notes** — Duet reads QuickBooks, Xero, Stripe, Harvest, Toggl, Notion, Linear, contracts, and project folders so it knows what was sold, what was delivered, and how the invoice should be described.
2. **Draft the invoice packet** — For each billable milestone or recurring period, Duet drafts the invoice, line items, supporting notes, purchase-order reference, and client-facing email. You approve the packet once instead of assembling it from five tabs.
3. **Prepare invoices on the right cadence** — Duet prepares invoices in your accounting tool with due date/payment link/tax details, then routes the packet for approval before send unless you configure a narrow repeat rule.
4. **Follow up without sounding desperate** — Reminder, due-date nudge, overdue follow-up, escalation — Duet writes each nudge politely in your voice and references the actual work delivered. The tone stays firm, not awkward.
5. **Reconcile payments and close the loop** — When money lands, Duet matches payments to invoices, marks them paid, updates the client record, and removes the account from follow-up. Partial payments and disputes get flagged with context.
6. **Surface cash risk every Monday** — Duet sends a simple cash brief: invoices sent, paid, overdue, aging buckets, clients at risk, and the next collection action. You know where cash is stuck before payroll week.
## FAQ
### Can Duet create invoices inside QuickBooks or Xero?
Duet can draft invoices in QuickBooks, Xero, Stripe, or another billing tool when the integration path supports it, then wait for approval before send. Start with approval required and enable narrow repeat rules later only after review.
### Will it chase clients too aggressively?
No. You define the cadence and tone. Duet can be soft for strategic accounts, firmer for chronic late payers, and always route sensitive clients to a human before any reminder is sent.
### Can it invoice from time tracking or project management tools?
Yes. Duet can pull billable hours, milestones, completed tasks, and retainers from tools like Harvest, Toggl, Linear, Asana, Notion, and Google Sheets, then turn them into invoice line items.
### Does Duet process payments?
Duet prepares and sends payment links through your existing provider, such as Stripe, QuickBooks Payments, or Xero. Actual money movement stays inside the payment system you already trust.
### How does it handle disputed invoices?
Disputes are escalated with the invoice, contract terms, delivery notes, and prior emails attached. Duet drafts a response, but the decision stays with you.
### Is this useful for agencies and service businesses?
Yes. Agencies, consultants, contractors, clinics, and other service businesses are a strong fit because invoicing depends on scattered delivery proof. Duet pulls that proof together and keeps the follow-up cadence running.
---
Source: https://duet.so/use-cases/by-job/newsletter
# Run your newsletter with an AI coworker
A newsletter should be a distribution engine, not a monthly guilt trip. Duet gathers the week of product updates, customer wins, posts, and metrics, turns them into a tight email in your voice, prepares the broadcast in your provider, and closes the loop with what readers actually clicked after the campaign is sent.
## The workflow
1. **Connect the sources of truth** — Duet reads the places your updates already live: GitHub, Linear, Notion, Slack, blog drafts, product analytics, and the last few newsletters. It builds the raw material without asking someone to paste a recap into a doc.
2. **Pick the angle for the week** — Duet clusters the updates into themes and proposes the strongest one: a launch, a customer story, a workflow people can copy, or a behind-the-scenes build note. The email gets a point instead of becoming a changelog.
3. **Draft in your voice and format** — Duet writes the subject line, preview text, lede, sections, CTA, and P.S. using your prior sends as the voice reference. It also builds the HTML or Markdown to match your template.
4. **Prepare the campaign for approval** — Duet checks the audience, suppressions, bounce history, and segment rules before approval in Resend, Customer.io, Mailchimp, ConvertKit, Loops, or your provider. The dangerous part stays reviewed.
5. **Repurpose the email into social posts** — The finished newsletter becomes a LinkedIn post, X thread, short product update, and internal changelog. One clear angle fans out across the channels your customers already read.
6. **Report and improve the next issue** — After the campaign is sent, Duet pulls opens, clicks, replies, unsubscribes, and bounces, then tells you what to keep, what to cut, and what topic deserves a deeper follow-up next week.
## FAQ
### Will Duet send emails without approval?
Not unless you explicitly allow it. A safer setup keeps final send behind approval, while letting Duet gather updates, draft the email, build HTML, check the audience, and prepare the broadcast for review.
### Which email platforms does it support?
Duet can connect to email platforms through integrations, APIs, exports, or custom wiring depending on the provider. For Resend, Customer.io, Mailchimp, ConvertKit, Loops, HubSpot, or Markdown-export workflows, scope draft, audience, and send permissions before enabling send.
### How does Duet know what happened this week?
It reads the systems where the work happened: commits, PRs, Linear issues, Slack threads, Notion docs, analytics, and support conversations. You get a real update, not a brainstorm from a blank page.
### Can it keep our brand template consistent?
Yes. Duet stores the approved template, colors, footer, mobile styles, unsubscribe placement, and CTA pattern. Each new issue starts from the same system instead of being rebuilt by memory.
### Can it clean or segment the list?
Yes. Duet can identify bounced, suppressed, inactive, high-engagement, product-user, and newsletter-only segments, then recommend who should receive a broadcast before anyone hits send.
### Does it help if we only send once a month?
Yes, but weekly or biweekly works better because the source material is fresher. Duet makes the operating cost low enough that a lean team can send more consistently without turning the newsletter into a part-time job.
---
Source: https://duet.so/use-cases/by-job/reporting
# Run internal reporting with an AI coworker
Reporting should make the next move obvious. Instead, lean teams lose hours pulling the same numbers into the same slides. Duet connects the sources, builds the daily or weekly brief, explains what changed, and sends the handful of decisions that matter. The report becomes the meeting.
## The workflow
1. **Connect the metrics sources** — Duet reads Stripe, PostHog, GA4, Search Console, HubSpot, Attio, Shopify, QuickBooks, spreadsheets, and databases. You define the handful of metrics that drive the business instead of dumping every chart into a dashboard.
2. **Define the brief people will read** — Pick the cadence and audience: daily founder pulse, Monday revenue brief, Friday client report, monthly board packet. Duet shapes the output to the reader instead of reusing one giant dashboard for everyone.
3. **Pull numbers and compare to baseline** — Duet fetches the latest metrics, compares them to last week, last month, forecast, or target, and flags changes that are large enough to matter. Noise stays out of the brief.
4. **Explain what changed** — When signups dip, churn spikes, traffic moves, or cash tightens, Duet checks the surrounding events: releases, campaigns, support volume, outages, seasonality. The report says why it probably happened, not just that it happened.
5. **Send the brief where work happens** — Email, Slack, Duet Files, Notion, Google Slides, or PDF — Duet posts the finished brief with the supporting links attached. Humans read the summary and click through only when they need detail.
6. **Track follow-up actions** — If the report recommends a pricing check, support reply, churn review, or SEO fix, Duet creates the task and follows up next week. Reporting becomes an operating loop, not a static artifact.
## FAQ
### How is this different from a dashboard?
A dashboard waits for you to interpret it. Duet pulls the numbers, explains the change, links the evidence, and recommends the next action. It is an analyst layer a small business can run without adding a full-time analyst.
### Can Duet build client-facing reports?
Yes. Duet can create polished client reports with only the metrics each client should see, plus plain-English commentary and next steps. Agencies use this to replace repetitive reporting assembly.
### Can it send scheduled reports?
Yes. Reports can run on a daily, weekly, monthly, or custom schedule. You can require approval for external reports while letting internal briefs send under the rules you set.
### What formats can it produce?
Email, Slack posts, Duet Files, Notion pages, Markdown, Google Docs, Google Slides, CSV, and PDF are all supported. The same source brief can become multiple formats.
### Can it handle messy spreadsheet data?
Yes. Duet can normalize sheets, detect missing columns, reconcile naming mismatches, and flag rows that need cleanup. It will not silently invent clean data where the source is broken.
### Who should use AI internal reporting first?
Founders, operators, agencies, and small teams with repeated weekly reporting pain. If someone spends each week making the same report, Duet should own that job.
---
Source: https://duet.so/use-cases/by-job/sales-outbound
# Run sales outbound with an AI coworker
Outbound is the job small teams skip because it eats the week. Duet is an AI coworker that coordinates outbound workflows from prospecting through reply logging: building your prospect list, enriching leads, drafting first touches in your voice, and running the pipeline admin loop without you babysitting it. Sales motion that compounds, without hiring an SDR.
## The workflow
1. **Define your ICP in one paragraph** — Describe who you sell to in plain English — industry, headcount, geography, the trigger that makes them ready to buy. Duet turns that into a structured filter you can re-run any time without touching a CRM screen.
2. **Build the prospect list** — Duet pulls matching accounts from Crustdata, Apollo, Clay, or LinkedIn Sales Navigator (whichever you already pay for), enriches each contact with email + title + tenure, and dedupes against your CRM so you never email the same person twice.
3. **Pick the trigger that makes the touch relevant** — Recent funding round, new hire on the team, a job posting, a stack change — Duet watches the signals you care about and only lines up outreach when there's a real reason to email today, not just a list with a SEND button.
4. **Write the first touch in your voice** — Duet drafts a concise email tied to the trigger, references one specific thing about the prospect, and signs off in your voice. You review the first batch in a side-by-side; approved drafts can be pushed to your sending tool, while risky or new-pattern drafts stay in review.
5. **Prepare the cadence for your sending tool** — Duet prepares the cadence for Instantly, Smartlead, Lemlist, or Gmail where connected; your sending tool handles warm-up, throttling, and domain rules.
6. **Handle replies the same way it triages support** — Positive reply, meeting-booked, not-the-right-person, soft-no, unsubscribe — Duet classifies every reply, drafts the right next step, and prepares a booking link or calendar hold for review. Nothing falls through the cracks because the inbox isn't where pipeline goes to die.
7. **Get a weekly pipeline brief** — On a weekly cadence, Duet sends a snapshot: replies this week, meetings booked, top patterns by reply (industry, persona, trigger), and which campaign to double down on. The next move is obvious, not buried in a sprawling dashboard.
## FAQ
### Is this just another "AI cold email" tool?
No. Duet is built for the full loop — ICP filter, list building, enrichment, trigger detection, drafting, sending, reply classification, follow-up — on one workspace with one coworker that remembers everything. Point cold-email tools are strongest at the drafting or sequencing step; Duet is for connecting the steps around them.
### How does it avoid spam folders and the deliverability disaster every founder runs into?
Duet hands the actual sending to your existing tool — Instantly, Smartlead, Lemlist — which already handles warm-up, domain rotation, and per-inbox throttling. Duet's job is the upstream work that makes deliverability matter: smaller, more relevant lists, one trigger per send, and copy that doesn't look like a generic blast sent the same week.
### Will it write meeting-worthy copy?
Meeting-worthy copy is short, specific, and trigger-aware — Duet writes to that pattern because it's reading the trigger, the prospect's last role move, and your best replies from recent history. It's not a generic personalization variable; the email actually references the thing that made the prospect worth emailing.
### How does it integrate with my CRM?
Duet can connect to CRM workflows through managed integrations, APIs, CSV, or custom wiring depending on the system. For HubSpot, Salesforce, Attio, Pipedrive, Folk, or Notion-as-CRM, scope the exact read, write-back, dedupe, and lifecycle-stage permissions before a campaign runs.
### What does it cost compared to hiring an SDR?
Hiring an SDR is a major fixed-cost bet, whether in-house or offshore. Duet offers monthly plans with included credits, making outbound research, drafting, and CRM updates easier to test before you commit to headcount.
### Will the outreach feel automated?
Only if you let it. Duet writes to your tone, references the specific trigger, and limits send volume to what a careful human SDR would do in a week. The point is to preserve the research quality and specificity of hand-written outreach while removing the repetitive drafting and CRM work.
---
Source: https://duet.so/use-cases/by-job/seo
# Run SEO operations with an AI coworker
SEO is not one magical blog post. It is a weekly operating cadence: find the gaps, fix the pages, add the links, watch the results, repeat. Duet turns that cadence into an always-on coworker so a small business can build search momentum without hiring an agency retainer.
## The workflow
1. **Map the pages you already have** — Duet crawls your site, reads titles, descriptions, headings, schema, internal links, and indexability. The first output is a clean map of what exists and which pages are actually capable of ranking.
2. **Find keyword gaps worth owning** — Duet pulls Search Console, competitor pages, and keyword data, then filters for topics a lean team can realistically win. You get a short list of pages to create or update, not a thousand-row keyword dump.
3. **Rewrite the pages that are close** — For pages already near page one, Duet updates the meta, headings, FAQ block, schema, and missing sections in a branch or CMS draft. It preserves your voice and fixes the boring technical pieces humans avoid.
4. **Repair the internal link graph** — Duet finds orphan pages, thin hubs, and missing links from high-authority pages. It proposes exact anchor text and destinations so the site starts behaving like a deliberate tree instead of a pile of posts.
5. **Monitor rankings and AI citations** — Every week, Duet checks search impressions, clicks, query movement, and AI overview citation opportunities. The report focuses on what changed and what action to take next, not dashboard screenshots.
6. **Ship one compounding improvement every week** — New FAQ, refreshed title, stronger comparison section, missing schema, better internal link, new leaf page — Duet keeps the crawl moving. SEO becomes an operating rhythm a small team can actually maintain.
## FAQ
### Is Duet an SEO agency replacement?
For weekly operating work — audits, updates, link fixes, reports, and content briefs — Duet can cover a lot of what small businesses outsource. A specialist is still useful for strategy, migration planning, and high-stakes technical calls.
### Can Duet update my site directly?
Yes. Duet can open a pull request for code-based sites or draft changes in WordPress, Webflow, Ghost, Sanity, Contentful, or another CMS. You choose whether it publishes directly or waits for review.
### How does it avoid generic SEO content?
Duet starts from your actual product, customers, and existing pages. It writes specific sections, FAQs, and internal links based on what your site can credibly answer, rather than producing interchangeable keyword sludge.
### Does it help with Google AI Overviews and answer engines?
Yes. Duet looks for definitional sections, citation-friendly summaries, FAQ schema, and missing structured answers. The same content that is clear for humans is easier for AI search systems to quote.
### How soon will SEO results show up?
Technical fixes and internal links can move impressions after focused fixes, but durable rankings depend on search demand and competition. Duet is useful because it keeps shipping the small improvements every week instead of letting SEO become a quarterly panic.
### What data sources does it use?
Search Console, analytics, sitemap data, crawler output, competitor pages, keyword providers, and the site itself. Duet turns those inputs into a prioritized worklist and then executes the work.
---
Source: https://duet.so/use-cases/founders
# Duet for startup founders
You're earlier than the role you're playing. Duet is AI for startup founders who would rather ship than schedule — it builds the MVP, runs the market research, drafts the deck, and sends the investor update, so you stop being the bottleneck on every function at once. Less hire-the-cofounder, more deploy-the-cofounder.
An AI coworker for founders is a persistent, cloud-based AI teammate that runs every function a one-person founder usually juggles — prototypes, market research, outreach, recruiting prep, decks, and weekly updates. It does the work from a single workspace, remembers prior context, and prepares each move for review so the founder stops being the bottleneck on every function at once.
## What it does
### Build a working MVP from a one-page spec
Ask it: "Build the MVP described in /spec/v1.md. Use Next.js + Convex + Resend. Set up auth with Convex Auth. Deploy to Vercel and seed the demo data from /spec/seed.json."
Outcome: Demo ready for review
### Run market and competitor research
Ask it: "On a weekly cadence, pull updates from our 8 competitors' pricing pages, changelogs, and LinkedIn posts. Summarize the diff in #market-watch."
Outcome: Recurring intel, zero clicks
### Draft fundraising decks and one-pagers
Ask it: "Draft a 12-slide seed deck using /memos/seed-narrative.md, our latest metrics from Stripe, and the design system in /brand. Output as Google Slides."
Outcome: Deck v1 from your source material
### Send monthly investor updates
Ask it: "Draft the November investor update: pull MRR from Stripe, top 3 wins from #wins, the ask for the month, and last month's asks revisited. Email me v1 for review."
Outcome: From blank page to review-ready draft
## The problems it picks up
### Code you can't justify hiring for
""I have a rough idea. I need a prototype the team can react to.""
Duet ships a working MVP — frontend, backend, deploy — from a spec written like a story. You ship a real product to test the wedge, not a pitch deck — which means real users, real signups, and real conversations with the people who actually want the thing.
### Research that should be automated
""I keep rebuilding the same competitor sheet.""
Duet runs deep competitor and market research on a schedule, files findings into a shared doc, and pings you when something interesting moves. Pricing pages, changelogs, LinkedIn posts, hiring patterns — watched continuously without you reopening another spreadsheet.
### Investor updates that don't happen
""I haven't sent an update since the angel round.""
Duet drafts the monthly update from your metrics, your workspace history, and your roadmap — you edit, you hit send, the cap table stays warm. The same scaffolding builds the board deck the quarter you raise, so you stop starting from a blank Google Slide.
## Before and after
### Without Duet
- You context-switch between code, sales, and decks all day.
- A backlog of "I'll do it Monday" tasks that never get done.
- Investor updates done quarterly, badly, with guilt.
- A Notion full of competitor links you never reopen.
### With Duet
- A cofounder-shaped AI that actually executes the spec.
- Recurring research, drafting, and shipping that runs on cron.
- Updates and decks drafted from real data, ready to polish.
- You back in the seat where founders should be — selling and building.
## How it works
1. **Give Duet the founding documents** — Share your spec, your brand, your metrics dashboards, and your last investor update. Duet builds a memory of the company so it can write in the founder voice — your phrasing, your numbers, your roadmap, your customers' names — instead of generic startup boilerplate.
2. **Delegate functions, not tickets** — Hand off whole functions — research, drafting, MVP build — instead of micromanaging tasks. Duet runs them on cron and pings you for review when there's a decision to make or a draft worth your time, not for every keystroke.
3. **Ship and review weekly** — On a regular review cadence, scan Duet's output: the MVP it shipped, the update it drafted, the research it surfaced. Approve, edit, or redirect. The flywheel keeps spinning between reviews, so planning opens with progress instead of a stale backlog.
## FAQ
### Can Duet really build a usable MVP?
Yes. Duet writes real production code (Next.js, Convex, Supabase, Vercel deploys) from a spec. The goal is a working demo you can put in front of a design partner, with a codebase that is yours to take to GitHub the moment you outgrow no-code.
### Is it better than just using Cursor or Claude Code?
Coding assistants help you type faster on your laptop. Duet runs on its own cloud server, persists state, schedules work, and handles non-coding functions (research, decks, updates) in the same workspace. For a founder running every function alone, that's a different shape of product — Cursor speeds up Tuesday; Duet runs all five weekdays.
### How does Duet handle sensitive metrics and investor data?
Your workspace is a private cloud server with isolated storage. Stripe keys, board materials, and metric dashboards stay scoped to your org — no cross-tenant exposure and no training on your content. Secrets live in encrypted environment variables that Duet reads at runtime, never logged or surfaced.
### Can I bring Duet into a team workspace later?
Yes. Start solo, then invite a cofounder or contractor. Shared files and Train sources stay with the workspace, so the new member can work from the same codebase, customer context, and operating knowledge.
### What does it cost at pre-seed?
Usage-based — solo founders can start with a small credit pack while validating. There's no per-seat tax, so adding contractors doesn't multiply the bill. When you raise and ramp output, the line item scales with the work, not with headcount.
### Will my investors care that I shipped this with AI?
The serious ones care about traction, judgment, pace, and burn discipline — not which keys you pressed to ship the build.
---
Source: https://duet.so/use-cases/operations
# Duet for operations teams
Operations is the role that absorbs everyone else's tax. Duet is AI for operations teams that wants to stop being the help desk — it runs the scheduling tetris, the document plumbing, the weekly report, and the support triage, so your ops team can finally fix the system instead of being the system.
An AI coworker for operations is a persistent, cloud-based AI teammate that handles the recurring back-office work an ops lead usually does manually — document extraction, vendor and renewal tracking, scheduling, internal reporting, and support triage. It connects to the systems you already use, remembers process context, and runs the repetitive pieces under your review rules so the ops team stops being the bottleneck.
## What it does
### Schedule meetings and coordinate calendars
Ask it: "Book a 30-min onboarding call between Sara (sara@example.com) and our CSM team next week. Prefer Tue/Thu afternoons in Sara's timezone. Send a calendar invite with the onboarding doc attached."
Outcome: One message instead of calendar ping-pong
### Automate document workflows
Ask it: "When a signed MSA lands in /contracts, extract counterparty, start date, term, and total value. Write a row to the renewals sheet and create a ticket in Linear ahead of renewal."
Outcome: Renewals tracked without a human
### Ship recurring reports and dashboards
Ask it: "On a weekly cadence, pull recent numbers from Mixpanel, Stripe, and HubSpot. Generate the weekly ops report PDF and email it to the leadership distro."
Outcome: A cleaner Friday reporting ritual
### Triage support tickets and inbound requests
Ask it: "For every new Zendesk ticket: tag urgency, suggest the right macro reply, attach the linked customer record, and ping the on-call engineer if priority is high-priority."
Outcome: Urgent tickets escalated clearly
## The problems it picks up
### Meeting scheduling is a full-time job
""Half my week is calendar Tetris.""
Duet reads the request, checks the calendars, proposes the slot, and prepares the invite under your calendar rules. The whole back-and-forth becomes one message — and the same flow runs for renewals, QBRs, customer onboardings, and the all-hands you keep rescheduling.
### Documents move by hand
""We literally re-type the contract into the renewal sheet.""
Duet pulls fields out of contracts, MSAs, and onboarding forms; writes them into the right systems; and flags anything that doesn't match. The data lives in one place instead of three, and renewals stop sneaking up on you because the dates were buried in a PDF.
### Weekly reports drain Friday
""I lose too much Friday focus to one PDF.""
Duet compiles the report — metrics, summaries, charts — straight from the source systems and emails it to the distribution list on schedule. The reporting window becomes a review pass instead of a manual assembly job, and the report can still ship when you're out.
## Before and after
### Without Duet
- Ops team buried in calendar threads and inbox triage.
- Contract data re-typed into 3 different systems.
- Focus lost to one report. Then another report.
- Tickets stack up; SLA breaches show up in QBRs.
### With Duet
- Scheduling, intake, and routing handled by Duet.
- Document data flows into systems of record under your routing rules.
- Reports compiled, formatted, and delivered on schedule.
- Tickets triaged quickly, escalations clearly flagged.
## How it works
1. **Map the workflows** — Walk Duet through the workflows that eat your week: scheduling rules, document templates, report formats, ticket SLAs. Save each one as a reusable playbook in workspace Files so the next person on the ops team doesn't have to re-explain the system from scratch.
2. **Wire up the systems** — Connect calendars, Drive, Notion, Slack, Linear, Zendesk, your data warehouse. Duet reads, writes, and triggers across the stack through scoped permissions, and workflows can reuse a connection once it is wired in.
3. **Run on schedule, on event, on demand** — Workflows fire on cron (the weekly report), on event (a contract lands), or on demand (someone asks in Slack). You see what ran and what needs a human in a single feed — no hunting through five different tool logs.
## FAQ
### How is this different from Zapier or Make?
Zapier and Make are deterministic plumbing — if X then Y. Duet handles the steps in between that need judgment: parsing an unfamiliar contract, writing a customer email, deciding which playbook applies. It uses Zapier-style triggers where they fit and reasons through the parts that don't.
### Can it write to our systems of record?
Duet can connect to ops stacks through managed integrations, APIs, CSV exports, or custom wiring depending on the system. Google Workspace, Notion, Linear, Asana, Jira, Zendesk, HubSpot, Salesforce, Snowflake, and BigQuery-style workflows should be scoped by permissions, fields, and approval rules before write access is enabled.
### How do we keep approval gates where they matter?
You define them per workflow. Anything Duet writes externally (emails, customer-facing messages, contract changes) can route through a human approval step before it goes out. Low-risk internal updates — moving a ticket, updating a CRM field — can run without manual review when you choose; sensitive writes can stay reviewed.
### What if a workflow breaks?
Duet logs every run and surfaces failures. You can replay a failed run, edit the workflow in plain English, and re-run — no need to dig into integration logs. The error tells you which step failed and what it was trying to do in human terms.
### How long until we see time back?
Duet is designed to reduce the recurring coordination work that eats ops calendars. The wins are concentrated on recurring workflows you run — scheduling and recurring reports are common starting points, with document workflows landing after Duet has seen enough variants of the inbound formats.
### Does it replace our ops manager?
No. Ops managers design the system; Duet runs it. The job shape changes — less keyboard time, more time on the workflows you used to skip because they took too long to wire up. Ops teams use Duet to take on a function they couldn't staff for, and reframe the role from coordinator to system designer.
---
Source: https://duet.so/use-cases/sales-teams
# Duet for sales teams
Your reps are great on the phone and terrible at the keyboard. Duet is AI for sales teams that closes the admin gap — it enriches every inbound lead, prepares the outbound sequence for review, keeps Salesforce current, and drafts the follow-up the rep forgot. They sell. Duet handles the admin loop under your rules, and the pipeline stays believable on a Monday.
An AI coworker for sales teams is a persistent, cloud-based AI teammate that owns the work between meetings — account research, list building, enrichment, draft outreach, CRM hygiene, and pipeline briefs. It runs on your data and in your tone, keeps the CRM honest, and prepares the next move under your review rules so reps spend their hours in conversations, not in tabs.
## What it does
### Enrich inbound leads as they arrive
Ask it: "Every new HubSpot lead: pull company size from Crunchbase, tech stack from BuiltWith, and recent LinkedIn posts. Drop a one-pager in their record and Slack the AE."
Outcome: Inbound leads enriched without copy-paste
### Run outbound email sequences with review rules
Ask it: "Pull Series A SaaS CFOs from /lists/q4-cfo.csv. Personalize the sequence from /sequences/cfo-v3.md using each company's latest funding round. Queue it for review before approval in our sending tool."
Outcome: Personalized outbound queued without copy-paste
### Keep the CRM clean and current
Ask it: "On a weekly cadence, read recent Gong calls, update deal stages in Salesforce, fill missing decision-maker fields, and flag deals with stale activity."
Outcome: Pipeline you can actually trust
### Automate post-meeting follow-ups
Ask it: "When a tldv call ends, draft a follow-up email in the rep's voice that recaps the call, restates the next step, and attaches the relevant case study from /case-studies."
Outcome: Follow-up draft ready before they're back at their desk
## The problems it picks up
### Inbound leads sit unqualified
""By the time we research them, they've gone cold.""
Duet enriches every inbound the moment it lands — company size, stack, funding signals, recent LinkedIn posts — and pushes a one-pager to the rep with the suggested opening. The lead is research-ready before the prep call that used to come first.
### Outbound is a copy-paste job
""My SDRs lose too much time in spreadsheets, not on the phone.""
Duet coordinates the outbound sequence: pulls the list, personalizes each email, queues approved sends in your sequencing tool, and logs replies in the CRM. The SDR's job stops being the spreadsheet and goes back to being the conversation that actually creates a meeting opportunity.
### CRM hygiene is a fairy tale
""Half the deals in pipeline have stage dates from last quarter.""
Duet reads every meeting transcript and email thread, updates stages, fills missing fields, and flags deals that have gone quiet for review. The pipeline meeting opens with the truth, not with the version your team had time to type after the last call.
## Before and after
### Without Duet
- SDRs losing large chunks of the day to research and data entry.
- Sequences sent in batches because personalization is tedious.
- A CRM that drifts out of date between pipeline reviews.
- Follow-ups that go out late, or never.
### With Duet
- Reps on the phone. Duet doing the typing.
- Outbound sequences personalized at the company level, sent on cadence.
- A CRM that updates itself from calls, emails, and meetings.
- Follow-ups drafted while the meeting context is still fresh.
## How it works
1. **Connect the revenue stack** — Plug Duet into HubSpot or Salesforce, your email, Gong/tldv, and your enrichment APIs. It indexes your pipeline, your templates, and your past wins — so the next email it drafts sounds like the one that actually closed last quarter.
2. **Hand off the repetitive plays** — Tell Duet which plays to run: inbound enrichment, outbound sequence, CRM cleanup, follow-up. Each one runs on event or schedule — no rep intervention needed — and the rep keeps a real-time view of what fired, what landed, and what needs them.
3. **Reps approve the high-stakes stuff** — Duet drafts; reps approve outbound copy, escalations, and exec emails before send. Everything else just happens, with an audit log of every send, every CRM update, and every customer touch the AI made on the team’s behalf.
## FAQ
### Does Duet replace SDRs?
No — it handles the parts of the SDR day that don't require a human. Reps still own the conversation, the discovery question, and the close. Duet owns the prep, the typing, and the admin work reps complain about most.
### Will it work with our existing CRM?
Duet can connect to CRMs through managed integrations, APIs, CSV, or custom wiring depending on the tool. HubSpot, Salesforce, Pipedrive, Attio, and Close-style workflows should be scoped against the fields and permissions your team wants Duet to touch.
### How do you prevent it from sending bad emails?
You set the approval rules. Drafts can stage for rep review, send through connected tools only after approval or under an explicit narrow repeat rule, or never send automatically. A safer rollout keeps everything in review first, then loosens the rules only where the risk is low.
### How does Duet learn our voice?
Show it real sent emails and a handful of wins. It adopts cadence, vocabulary, and signoff style. As you correct drafts, it gets closer to the rep's voice. The same voice carries across follow-ups, sequences, and inbound replies, so the prospect's inbox feels consistent.
### Is it compliant for regulated industries?
Workspaces are isolated, data is scoped to your org, and outbound sending honors CAN-SPAM and your suppression lists. Talk to us about specific compliance frameworks (SOC2, HIPAA-aligned setups) — we'll walk through what's in place today and what's on the roadmap.
### What about deliverability — won't AI-sent email get spam-flagged?
Duet sends from your domain, through your warmed-up mailbox, with rate limits that mirror a human SDR's pace. No bulk blasts, no spoofed senders, no fingerprint that screams bot. Sequences can pause when the sending tool exposes reputation or deliverability signals, then ping the rep before more email goes out; the underlying ESP integration handles SPF, DKIM, and DMARC the way your IT team already configured them.
---
Source: https://duet.so/use-cases/small-businesses
# Duet for small business owners
You're the founder, the marketer, the IT desk, and the bookkeeper. Duet is AI for small business owners who actually run the business — it builds the site, drafts the email, sets up the spreadsheet, and gets the first recurring workflow ready for review. One coworker, one workspace, the operating loop you kept meaning to systemize.
An AI coworker for small business owners is a persistent, cloud-based AI teammate that builds and runs the recurring work an owner usually does after hours — the website, the support inbox, the invoice tracker, the customer onboarding flow. Unlike a chatbot, it lives in its own workspace, remembers your business between sessions, and ships under your review rules so a one-person shop can operate like a small team.
## What it does
### Build and ship your business website
Ask it: "Build a 1-page site for Pine & Pour, a wine bar in Austin — menu, hours, reservations form, and an Instagram block. Deploy it to pineandpour.duet.so."
Outcome: Ready for review from one brief
### Create internal apps without an engineer
Ask it: "Build me an invoice tracker. Pull customer data from our Google Sheet, let me mark invoices paid, and email a reminder on the follow-up date if unpaid."
Outcome: Working app from a plain-English brief
### Manage support emails and customer messages
Ask it: "Read recent messages in support@, draft replies in our tone, and put the ones that need a refund into a "needs me" bucket."
Outcome: Drafts prepared, exceptions escalated
### Onboard new customers with a reviewable workflow
Ask it: "When a Stripe payment lands, generate a welcome email, create their Notion workspace from the template, and book a kickoff in my calendar."
Outcome: Onboarding packet queued for review
## The problems it picks up
### The website you never finish
""I've been meaning to redo our site since last year.""
Duet builds a real, fast, indexable site from a short brief — copy, images, contact form, the lot — and hosts it on a Duet subdomain or your own. When you want a price tweak, a new product card, or a holiday banner, you ask in plain English and Duet can make the update from the same workspace.
### Support email pile-up
""By Friday my inbox is a graveyard.""
Duet reads every support thread, drafts a reply in your voice, flags the ones that need you, and labels the rest so review is fast. The inbox becomes a reviewed queue — not a graveyard — and the customers who actually need a human are sitting at the top.
### Tools you can never afford to build
""We need a tiny dashboard, but no developer wants the job.""
Duet writes the internal tool from scratch — invoice tracker, booking form, stock checker — and runs it on your workspace so you stop juggling spreadsheets. It comes with a real database, real authentication, and a real URL, so the people you want using it can just open the link.
## Before and after
### Without Duet
- Five tabs open, four half-finished tools, one website that never shipped.
- Recurring support backlog you clear outside work hours.
- Quotes for a "simple dashboard" that turn into a custom-project rabbit hole.
- New customer onboarding done from memory, in DMs.
### With Duet
- One Duet workspace that builds, ships, and runs the work.
- Inbox triaged daily, drafts ready when you sit down.
- Internal apps written in plain English and hosted for you.
- A repeatable onboarding flow that runs when Stripe records a payment.
## How it works
1. **Point Duet at your business** — Share your website, your inbox, and the tools you live in. Duet reads your brand voice, your past replies, your pricing pages, and the recurring workflows you run — without turning setup into a discovery sprint.
2. **Ask in plain English** — Tell Duet what you actually need — "rebuild our site," "draft replies in my voice," "spin up an invoice tracker." No prompt engineering, no template gallery to browse, no integrations to set up first. You describe the job; Duet picks the tools.
3. **Run it on a schedule** — Duet ships the work to a real server, sends drafts back to you for approval, and runs the recurring pieces on schedule. You stay in the loop, not in the weeds — review what ran this morning, redirect what didn’t, and keep the low-risk pieces moving under your rules.
## FAQ
### Do I need to be technical to use Duet?
No. Duet is built for owners and operators who don't write code. You describe the work in plain English; Duet does the typing, the building, and the deploying. The closest thing to setup is connecting the tools you already use — Gmail, Drive, Stripe — and pointing Duet at your business URL.
### Can Duet really build a website that ranks?
Duet can generate crawlable, fast, SEO-ready pages with metadata, schema, sitemap entries, and Open Graph cards — not a glorified PDF. Rankings still depend on domain authority, content quality, links, search intent, and competition, so treat Duet as the system that gets the page ready and keeps improving it.
### How does Duet handle our customer data?
Every Duet workspace gets its own private cloud server with isolated storage and memory. Your customer data, drafts, and integrations stay scoped to your team — no shared multi-tenant pool, no training on your content, and no surprise cross-tenant exposure if a neighboring workspace gets compromised.
### What does it cost compared to hiring a part-time VA?
A part-time human assistant is a recurring labor cost with limited coverage. Duet has monthly plans with included credits and fits best when repeatable work spans tools, files, and approvals inside your workspace.
### Will Duet replace my team?
No. Duet takes on repeatable work your team could not get to — the website you never shipped, the inbox you never cleared, the tool you never built. Your team gets to focus on the things that actually need a human in the room: the customer conversation, the judgment call, the relationship.
### How long does setup take?
Start by connecting a URL, inbox, or calendar and handing off one workflow. The first useful output depends on the workflow and tools connected.
---
Source: https://duet.so/use-cases/small-businesses/service-business-owner
# Run your service business with a cloud AI assistant
You run a salon, a clinic, a contracting crew, a cleaning business. The phone never stops, the inbox is a mess by Friday, and half your leads never get a follow-up. Duet sits on top of your existing tools — Google Calendar, QuickBooks, Jobber, your phone forwarding — and runs the front office while you're on a job site.
## The workflow
1. **Point Duet at your calendar and inbox** — Connect Google Calendar (or Calendly, Acuity, or Jobber), your business email, and your phone forwarding number. Duet learns your service menu, your pricing, your hours, and the way you talk to customers from your past replies.
2. **Capture leads on every channel** — Inbound text, missed call, website form, Yelp message — Duet drafts the booking link or a clarifying question, then keeps the conversation moving until the lead either books or opts out. The goal is fewer leads sitting untouched while you're on the job.
3. **Book and confirm appointments with review rules** — Duet proposes a slot from your calendar, gets confirmation by text or email, and writes the appointment into your booking system — with the customer’s notes, the service requested, and the address. It can also send reminders and reschedule if they reply asking to move.
4. **Send invoices and chase the slow payers** — After a job, Duet drafts the invoice in QuickBooks or Jobber from the appointment notes, sends it for your approval, and then follows up on a polite cadence. You review the exceptions instead of rebuilding the same invoice workflow every time.
5. **Ask for the review at the right moment** — After the job is marked complete, Duet can send a personalized request for a Google review — with the customer's name, the service they got, and a direct link to your Google Business Profile. More consistent review requests give you a better shot at building local trust.
6. **Get a Monday-morning roundup of the week ahead** — On a weekly cadence, Duet emails you open bookings, the leads still on the fence, the invoices unpaid, and the slots that are still open. You start the week knowing exactly where to push.
## FAQ
### Does Duet work with Jobber, ServiceTitan, or Housecall Pro?
Duet can connect to service-business systems through managed integrations, APIs, email, CSV exports, or custom wiring depending on the tool. For Jobber, ServiceTitan, Housecall Pro, Workiz, or a smaller system, the setup should be scoped against the exact API access and permissions available.
### Can it answer the phone?
Duet doesn't replace your phone line, but it can pick up missed calls and SMS via Twilio, OpenPhone, or your existing call forwarding. The caller gets a booking link or a human-sounding follow-up — so fewer leads drift to your competitor across town.
### Will it sound like me, or like a robot?
It sounds more like you after it has examples of your past customer messages to read. The goal is for routine replies to feel familiar enough that regulars do not notice a handoff — and when Duet uses a phrase you would never say, you can correct that in one sentence.
### How does this compare to hiring a virtual receptionist?
A virtual receptionist is a recurring labor cost for scripted coverage. Duet has monthly plans with included credits and fits best when front-office work spans booking, invoices, payment follow-up, reviews, and customer context.
### Is my customer data safe?
Every Duet workspace is a private cloud server with isolated storage. Customer phone numbers, addresses, and job notes stay inside your workspace — no shared multi-tenant pool, no training on your content, no cross-tenant exposure if someone else's workspace is compromised.
### What if I don’t want Duet sending messages without me reviewing?
You pick the approval rule per workflow. A safer rollout starts with everything in review, then narrows explicitly enabled sends to low-risk confirmations or review requests while invoices and refunds keep needing a human tap. You can change the rule any time — it's one prompt to Duet, not a settings menu.
---
Source: https://duet.so/use-cases/small-businesses/shopify-store
# Run your Shopify store with an AI coworker
You're running a Shopify store and a customer service desk and a marketing team — alone. Duet plugs into your store, your inbox, and your ad accounts to help run the loop: product page copy, support replies, abandoned-cart sequences, and the analytics report you've been meaning to look at since launch.
## The workflow
1. **Connect your Shopify store and support inbox** — Point Duet at your store and your customer service inbox (Gmail, Help Scout, Gorgias, or plain support@). It pulls in your product catalog, brand voice, refund policy, and recent support tickets so its drafts can match how you already talk to customers.
2. **Generate product pages and category copy** — Hand Duet a product spec or a supplier PDF and it drafts the title, description, bullets, SEO metadata, and FAQ block — ready to publish through an enabled Shopify Admin path or paste in. Same flow rewrites stale category pages so the whole catalog is searchable, not just the bestsellers.
3. **Run support replies with human review** — Duet reads every new ticket, classifies it (where's my order, refund, sizing, wholesale), drafts a reply in your tone, and queues it for review. Anything ambiguous — a chargeback, a press request — escalates to you with the relevant context attached.
4. **Recover abandoned carts on cadence** — Connect Klaviyo or your built-in Shopify Email and Duet writes the abandoned-cart sequence — personalized to the cart contents and the customer’s previous orders. New variants can run on a cadence, with winners promoted after review.
5. **Get a weekly store report you can act on** — On a weekly cadence, Duet emails a one-page report: GMV trend, top SKUs, support volume and CSAT, ad ROAS, and the decisions that need attention. The report is the meeting; you can review it before the team sync.
## FAQ
### Does Duet work with the Shopify Admin API?
Yes. Duet authenticates against your Shopify store with scoped credentials and can read products, orders, and customers, and write product updates, draft orders, and metafield values. You approve the scopes during setup — nothing escalates without you re-authorizing it.
### Will the product copy sound like AI slop?
No, not if you give it strong examples. Once Duet has read your top-selling product pages, it mirrors your sentence length, the words you use for fit and material, the way you call out shipping, and the lines you put in the FAQ block. The goal is drafts that need editing, not rewriting.
### Can it handle returns and refunds?
Duet drafts the refund reply and proposes the refund in Shopify, but a human approves the actual money movement by default. You can loosen that rule per category once you trust the classifier — some teams later define low-risk categories or thresholds after review and keep edge cases escalated.
### Does it integrate with Klaviyo, Gorgias, and the rest of the Shopify stack?
Duet can connect to Shopify stacks through managed integrations, APIs, webhooks, IMAP/CSV, or custom wiring depending on the tool. Klaviyo, Gorgias, Help Scout, Postscript, Recharge, and Loop Returns-style workflows are best treated as scoped setup items, not assumed instant connectors.
### How is this different from a Shopify-native AI like Sidekick?
Sidekick lives inside the Shopify admin and helps you with one task at a time. Duet lives outside the admin, runs scheduled workflows on a cloud server, keeps memory across your workspace, and reaches into Klaviyo, Gorgias, your ad accounts, and your inbox. Use both — they don’t conflict.
### How fast can a one-person store be live with Duet?
Solo Shopify owners typically start with support drafts or abandoned-cart copy, then expand into product pages, email, and recurring reporting after a few review passes.
---
Source: https://duet.so/vs
# Duet comparisons
## Comparisons
- [Duet vs Lovable](https://duet.so/vs/lovable.md): Lovable is a focused app builder. Duet builds apps and runs them. A side-by-side look at which is right for solopreneurs, agencies, and small teams.
- [Duet vs Claude Code](https://duet.so/vs/claude-code.md): Claude Code is excellent inside a repo. Duet is better when the job needs cloud persistence, team context, scheduled work, and business operations.
- [Duet vs Claude for Small Business](https://duet.so/vs/anthropic-small-business.md): Claude for Small Business brings AI into existing tools. Duet gives SMBs a named AI coworker with memory, workspace, apps, and execution loops.
- [Duet vs Replit](https://duet.so/vs/replit.md): Replit is strong for building and deploying apps in the browser. Duet is built for small teams that need apps plus persistent business operations.
- [Duet vs v0](https://duet.so/vs/v0.md): v0 is excellent for generating UI. Duet is better when the UI needs to become a hosted app, recurring workflow, and shared business process.
- [Duet vs Cursor](https://duet.so/vs/cursor.md): Cursor is a great AI code editor for developers. Duet is a persistent cloud coworker for teams that need code, apps, memory, and operations.
- [Duet vs Codex](https://duet.so/vs/codex.md): Codex is powerful for software tasks and background coding. Duet is better when AI must run business workflows with memory, apps, and team context.
- [Duet vs Bolt.new](https://duet.so/vs/bolt.md): Bolt.new is strong for fast app generation in the browser. Duet is stronger when the app must keep running with memory, schedules, and team context.
---
Source: https://duet.so/vs/anthropic-small-business
# Duet vs Claude for Small Business: should AI be a tool toggle or a teammate?
Claude for Small Business wins if you want a familiar assistant inside your existing SaaS stack. Duet wins if you want to hire a persistent AI coworker with its own workspace, memory, files, apps, and recurring execution loops.
*Updated 2026-05-19 — Added Claude for Small Business after Anthropic moved directly into SMB workflow positioning.*
## Where Claude for Small Business wins
### Best-in-class model experience
If your need is mostly writing, analysis, summarization, or reasoning inside a chat assistant, Claude is excellent and may be the simplest answer.
### Enterprise familiarity
Teams that already buy from Anthropic or want a broad assistant layered into familiar tools may prefer Claude for Small Business because it feels like an extension of their existing stack.
### Horizontal assistant use cases
Claude is stronger when the job is broad knowledge work rather than owning a specific operational loop with files, schedules, apps, and recurring accountability.
## Where Duet wins
### A teammate, not a toggle
Claude for Small Business puts intelligence inside tools. Duet gives the business a named AI coworker with identity, memory, files, apps, and a place to come back to.
### Build + Run is the default loop
Duet can build the tool a small business needs, host it, wire it to the rest of the business, and then operate the recurring workflow behind it.
### Persistent workspace beats scattered context
When context lives across emails, docs, sessions, apps, and recurring jobs, Duet’s workspace model compounds. The AI coworker remembers what happened and why.
### Better metaphor for SMB adoption
Small businesses understand hiring help. Duet’s “hire your first AI coworker” frame is more actionable than asking an owner to become an AI systems integrator across a dozen SaaS products.
## FAQ
### Is Duet a Claude for Small Business competitor?
Yes, but only partly. Claude for Small Business is a broad AI assistant for work. Duet is a persistent AI coworker workspace for building apps and running business operations.
### Which is better for small business owners?
Claude is better for general assistant work. Duet is better when the owner wants to delegate recurring work, build internal apps, remember business context, and coordinate with a team.
### Does Duet use Claude models?
Duet can route work through multiple strong models depending on the task. The important difference is not the model alone; it is the workspace, memory, execution loop, and team context around the model.
### Can Claude for Small Business run scheduled workflows?
It can help with workflows through connected tools, but the recurring execution layer is not the core product. Duet is built around scheduled and long-running operational work.
### Which product is easier for non-technical teams?
For simple Q&A, Claude is easy. For delegating business outcomes, Duet is easier because the work lives in a shared workspace with sessions, files, approvals, and memory.
### Should I use both Claude and Duet?
Some teams will. Claude can be the everyday assistant for individuals, while Duet becomes the shared AI coworker that owns recurring workflows and custom business apps.
### Does Duet replace my existing SaaS tools?
Not entirely. Duet connects to existing tools where needed, but it can reduce the number of extra automation, reporting, and internal-tool products a small team has to manage.
### What is the main difference between Claude for Small Business and Duet?
Claude for Small Business is AI inside your tools; Duet is an AI teammate with its own workspace that builds, runs, and remembers work for your business.
---
Source: https://duet.so/vs/bolt
# Duet vs Bolt.new: should you build once or keep an AI coworker running?
Bolt.new wins when you want to generate or iterate on a web app quickly in a browser. Duet wins when the job is not finished at deploy: the app needs maintenance, integrations, scheduled work, team context, and an AI coworker that remembers the business.
*Updated 2026-05-19 — Published the Bolt.new comparison for founders choosing between one-shot app generation and persistent business execution.*
## Where Bolt.new wins
### One-shot app generation speed
Bolt.new is a better fit when the goal is to quickly create a web app prototype and iterate in a browser-based build environment.
### Developer-friendly build loop
For technical users who want code, preview, and edit in one fast surface, Bolt.new is more focused than Duet.
### Simple prototype economics
If you only need a short build sprint and do not need ongoing operations, a builder like Bolt.new can be the more efficient choice.
## Where Duet wins
### Duet does not stop at the prototype
Bolt.new helps you make the thing. Duet helps you make the thing and then keep it alive, updated, connected, and useful to the business.
### Operations are first-class
Duet can schedule reports, monitor work, triage support, update records, and ask for approval. That is the layer app builders often leave behind.
### The team can steer the AI together
Duet work happens in shared sessions with context and event history, so non-technical teammates can participate without entering a code editor.
### Memory compounds over time
The second app Duet builds benefits from the first app’s decisions, files, customer notes, and team conversations. That compounding memory is the point.
## FAQ
### Is Duet a Bolt.new alternative?
Duet overlaps with Bolt.new on app creation, but Duet is broader. Bolt.new is a fast app builder. Duet is a persistent AI coworker workspace for building and running business work.
### Which is faster for prototypes?
Bolt.new is a browser app generator built for fast prototypes. Duet is better when that prototype needs to become a live business process with hosting, schedules, integrations, and human approval loops.
### Can Duet work with a Bolt.new app?
Yes. If you export or save the app code, Duet can help host it, modify it, and connect it to recurring workflows.
### Which is better for non-technical users?
Bolt.new is approachable for describing an app. Duet is more approachable for delegating an outcome like “send this report every Monday” or “follow up with every new lead.”
### Does Bolt.new run scheduled operations?
Not as its core product. Bolt.new is centered on building. Duet is centered on build plus ongoing operation.
### Should agencies use Bolt.new or Duet for client delivery?
Bolt.new can speed up building. Duet is better when the agency sells ongoing outcomes and needs shared client context, approvals, and recurring execution.
### Can Duet build apps from natural language?
Yes. Duet can build apps from natural language, but its advantage is keeping the AI coworker around after the app ships.
### What is the main difference between Bolt.new and Duet?
Bolt.new helps you create an app. Duet helps you create the app and run the work around it.
---
Source: https://duet.so/vs/claude-code
# Duet vs Claude Code: should you hire a cloud AI coworker or use a terminal coding agent?
Claude Code wins when the job is pure software engineering inside a developer-owned repo. Duet wins when the job needs to live in the cloud, remember business context, coordinate with a team, and keep running after the code is written.
*Updated 2026-05-19 — Updated for Claude Code remote-agent momentum and Duet’s Build + Run positioning for SMB operators.*
## Where Claude Code wins
### Deep developer ergonomics
Claude Code is the better tool when your day is mostly commits, tests, refactors, and terminal-native iteration. It meets developers exactly where they already work.
### Local repo control
If you want the agent constrained to a repository on your machine with every file change visible in your normal Git workflow, Claude Code is cleaner and more direct.
### Engineering-only teams
For teams that already have CI, deploys, ticketing, ops runbooks, and human product owners, Claude Code can be the sharper coding blade without replacing the surrounding system.
## Where Duet wins
### Duet keeps working after the code is done
Claude Code is excellent at producing and changing code. Duet is designed for the longer loop: build the thing, host it, monitor it, update it, run the recurring job, and remember why it exists.
### Business context lives beside the work
In Duet, customer emails, notes, files, session history, app code, and future follow-ups live in one workspace. The AI coworker is not guessing from a repo alone.
### Teams can collaborate with the agent directly
Claude Code is mostly a developer-agent pairing. Duet lets founders, operators, marketers, and support teammates work with the same AI coworker through shared sessions without learning terminal workflows.
### Better fit for SMB operators
A small-business owner rarely wants a better terminal. They want invoices chased, a report sent every Monday, a landing page updated, and support triaged. That is Duet’s lane.
## FAQ
### Is Duet better than Claude Code?
Not for pure coding. Claude Code is better for terminal-native engineering inside a repo. Duet is better when the work needs a persistent cloud workspace, team collaboration, hosted apps, and recurring business operations.
### Can Duet write code like Claude Code?
Yes, Duet can write, edit, and debug code. The difference is that Duet wraps coding in a business workspace with memory, files, hosting, schedules, and human approvals.
### Should developers use Claude Code or Duet?
Developers should use Claude Code when they want the fastest coding loop in their local workflow. They should use Duet when the agent needs to keep running in the cloud or coordinate with non-developer teammates.
### Can I use Claude Code and Duet together?
Yes. A practical split is Claude Code for deep repo work and Duet for operating the business workflows, hosted tools, recurring reports, and team-facing AI collaboration around that code.
### Does Duet replace GitHub, CI, or a developer workflow?
No. Duet can work with existing developer workflows, but it is not trying to be a GitHub replacement. It is a cloud coworker workspace for building and running business work.
### Is Claude Code good for non-technical founders?
Only if they are comfortable with developer tools or have an engineer nearby. Duet is a better fit for non-technical founders who want to delegate outcomes instead of manage a terminal session.
### Which is better for scheduled tasks?
Duet. Claude Code can help write scripts, but Duet has the workspace, cron, memory, and approval surface needed to run scheduled business work repeatedly.
### Which tool is safer for external actions?
Duet is designed to put external actions in a shared approval flow. Claude Code is safe when a developer supervises it closely, but the approval model is less natural for a whole team.
---
Source: https://duet.so/vs/codex
# Duet vs Codex: should AI automate code or operate your business?
Codex wins when the work is primarily software engineering and you want OpenAI’s coding agent to handle repo tasks. Duet wins when the work crosses from code into the business: persistent workspace, hosted apps, recurring operations, team context, and human approvals.
*Updated 2026-05-19 — Updated for Codex’s move toward background automations, plugins, memory, and longer-running agent work.*
## Where Codex wins
### OpenAI ecosystem gravity
If your company is already standardized on OpenAI tools and wants a coding agent in that ecosystem, Codex is the natural choice.
### Software engineering task depth
Codex is strongest when the job is clearly framed as a coding task against a repository, CI failure, bug, or implementation plan.
### Scale of model and platform investment
OpenAI is investing heavily in long-running agents, plugins, memory, and background automations. That platform momentum is real.
## Where Duet wins
### Duet is not just for engineers
Codex may be powerful, but the natural user is still someone assigning technical work. Duet is designed so founders, operators, marketers, and support teams can all delegate work.
### The workspace is the product
Duet gives the agent a home: sessions, files, memory, hosted apps, recurring jobs, and approvals. That makes the AI coworker legible to the whole business.
### Build + Run for small businesses
A small business does not only need code. It needs the invoice sent, the customer followed up, the report delivered, and the internal app maintained. Duet’s loop starts there.
### Less platform abstraction, more teammate metaphor
Codex feels like assigning jobs to a powerful automation system. Duet feels like hiring the first AI teammate into the company workspace.
## FAQ
### Is Duet a Codex alternative?
Duet overlaps with Codex on AI coding, but Duet is broader. Codex is a coding agent. Duet is a persistent AI coworker workspace for apps and business operations.
### Which is better for coding?
Codex is the better specialist for coding tasks. Duet is better when coding is one part of a larger business workflow.
### Is Codex or Duet better for small business operations?
Codex is a background coding agent; Duet is shaped around small-business operations: hosted apps, memory, approvals, recurring work, and team collaboration around the AI coworker.
### Can Duet run long tasks like Codex?
Yes. Duet is built around cloud sessions and durable work. The distinction is that Duet ties that work to a shared business workspace.
### Can I use Codex and Duet together?
Yes. Codex can handle engineering-specific tasks while Duet owns the business-facing workspace, operations, reporting, and cross-functional follow-through.
### Does Codex have memory?
OpenAI is moving toward more memory and longer-running agents. Duet’s advantage is tying memory to a concrete workspace with sessions, files, apps, and recurring workflows.
### Which is safer for business approvals?
Duet’s approval model is more natural for business teams because external actions can be reviewed in shared context. Codex is safest when supervised by technical users.
### What is the practical difference?
Codex automates software work. Duet automates the business work around the software.
---
Source: https://duet.so/vs/cursor
# Duet vs Cursor: should AI live in your editor or in your business workspace?
Cursor wins when the work is developer-owned and the center of gravity is your editor. Duet wins when the work needs a persistent cloud agent that collaborates with the whole team, hosts apps, and runs business operations after the coding session ends.
*Updated 2026-05-19 — Updated after Cursor’s agent context and CI-agent momentum made the editor-vs-workspace split clearer.*
## Where Cursor wins
### Editor-native engineering
Cursor is the right answer if your problem is moving faster through a codebase you actively edit every day.
### Developer muscle memory
Cursor fits into a familiar IDE workflow. Developers can keep their extensions, shortcuts, file tree, terminal, and Git habits.
### Large codebase understanding
For navigating references, making focused edits, and reviewing code in context, Cursor’s editor-first design is a real advantage.
## Where Duet wins
### Duet is visible to the whole team
Cursor work mostly happens in a developer’s editor. Duet work happens in shared sessions where operators, founders, support, and engineers can all see and steer the AI coworker.
### The workspace persists after the editing session
Duet’s cloud server, files, memory, and apps survive across days and teammates. The work does not disappear when a developer closes their editor.
### Build + Run beats edit-only
Duet can change code, but the bigger win is operating the result: hosting the app, running the report, checking the inbox, updating the CRM, and asking for approval.
### Better for lean non-technical teams
A small business does not want to buy an IDE for every operator. Duet gives the whole team an AI coworker they can talk to in plain language.
## FAQ
### Is Duet better than Cursor?
Not for pure coding. Cursor is better as an AI code editor. Duet is better as a persistent AI coworker workspace for apps, memory, team collaboration, and business operations.
### Can Duet edit code like Cursor?
Yes, Duet can edit and debug code. Cursor is more optimized for the developer editor experience, while Duet is optimized for the full build-and-run workflow.
### Which should a non-technical founder choose?
Duet. Cursor assumes you are comfortable operating inside an IDE. Duet lets you delegate business outcomes in a shared workspace.
### Can I use Cursor and Duet together?
Yes. Cursor can be the developer’s editor, while Duet acts as the shared cloud coworker for running workflows, hosting apps, and keeping team context.
### Which is better for CI fixes?
Cursor is strong for developer-facing CI and code review workflows. Duet is better when CI results should trigger broader operational follow-up or team-visible agent work.
### Does Duet replace my IDE?
No. Duet is not trying to replace every developer’s IDE. It gives the business a persistent AI workspace that can also write code.
### Should agencies use Cursor or Duet for client delivery?
Cursor is great for agency engineers. Duet is better for agencies that want client workspaces, recurring deliverables, approvals, and AI-operated production work.
### What is the simplest distinction?
Cursor lives where developers write code. Duet lives where the business delegates work.
---
Source: https://duet.so/vs/lovable
# Duet vs Lovable: Which is better for small business in 2026?
Lovable wins if you want a focused app build. Duet wins if you need that app to keep running after launch.
*Updated 2026-05-18 — Lovable shipped iOS/Android apps and closed a major funding round; we updated pricing, features, and the verdict accordingly.*
## Where Lovable wins
### App generation polish
Lovable's UI for “describe an app and watch it build” is best-in-class. The previews, the iteration loop, the deploy-on-save flow — it's faster than Duet for pure web-app generation.
### Mobile-first builder
Lovable's iOS and Android apps (shipped May 2026) let you vibe-code from your phone with voice. Duet has mobile apps too, but they're for collaboration with your AI coworker, not for building from scratch on a phone.
### Onboarding for first-time builders
Lovable's templates and starter prompts are tuned for “I've never built anything” users. Duet assumes you already have a small business to run, so the on-ramp is shaped for operators rather than absolute first-time builders.
## Where Duet wins
### Lovable is build-first. Duet builds and runs.
Lovable's job is over at deploy — your app is now your problem to operate. Duet's job starts at deploy: the same workspace that built the app triages the support inbox, sends scheduled reports, integrates with Stripe and Shopify and your CRM, patches bugs you spot, and builds the next app that depends on it.
### Your own private server, not shared infra
After public security concerns around generated-app platforms in 2026, infrastructure isolation matters when customer data lives inside generated apps. Duet gives every workspace its own isolated server — customer data, conversations, and code are not pooled into a shared app-builder environment.
### Persistent memory that compounds
Lovable remembers your prompts within a chat. Duet remembers everything across sessions, across team members, across months — the coworker that built your customer dashboard in March remembers in October why you made that one weird design choice and what the customer feedback was. That's the difference between an AI tool and an AI coworker.
### Team-native by default
Lovable Workspaces 2.0 (Pro plan) gets you unlimited collaborators on a build-centric surface. Duet is team-native by design — humans and your AI coworker share sessions, files, apps, and context, with every run preserved as a visible event history. For agencies and small teams where the AI is the third employee, not the eleventh tool, the workflow shape is fundamentally different.
## FAQ
### Is Duet a Lovable competitor?
Partially. We overlap on "build apps from natural language," but the real Duet product is the full operate-your-small-business workspace. Lovable is a builder. Duet is a teammate.
### Can Duet build apps as fast as Lovable?
For typical CRUD-style business apps, yes. Lovable is faster on the polish of the build UX. Duet can be faster for workflows that need ongoing operations because it doesn't hand you an operations problem at the finish line.
### Is Lovable security scrutiny a real concern for small businesses?
If you store customer data in a generated app, the underlying infrastructure model matters. Duet's per-workspace isolation is built to reduce the blast radius of shared-infrastructure risk.
### Can I use both Lovable and Duet?
Yes. Some users prototype in Lovable, then move production builds to Duet for ongoing ops. That's a totally reasonable pipeline — Lovable for the build sprint, Duet for the years afterward.
### Can I try Duet before subscribing?
Yes. Start with a 7-day free trial, then choose Starter, Pro, or Max to keep running charged work. Each monthly plan includes credits.
### What if I just want to vibe-code on my phone?
Use Lovable. Their mobile builder is purpose-built for that. Duet has mobile apps, but they are tuned for collaborating with your AI coworker on running work, not for building from scratch on a phone.
### How is Duet different from Lovable plus Zapier plus ChatGPT?
That stack introduces more moving parts: separate memory, separate automation logic, and multiple vendors to coordinate. Duet keeps the work in one workspace with one teammate that remembers what you have already done.
### What about pricing for high-usage teams?
Duet offers monthly plans with shared included credits. Adding humans to the workspace does not multiply the subscription the way SaaS seat pricing does; reserve topups cover overage.
### Can my AI coworker access my Lovable-built app?
Yes — once you migrate it into a Duet workspace, your AI coworker can operate the app, monitor it, and extend it. Duet can connect external services through the integration path you enable, depending on credentials and permissions.
### Is Duet open source?
Some surrounding developer tooling is open source. The Duet web product and managed control plane are closed-source SaaS hosted on Duet infrastructure.
### Will Duet replace developers?
For solo founders and small businesses, Duet can cover many internal SMB tools. Complex production systems still need developers; your AI coworker is a force multiplier, not a replacement.
### How do I get started with Duet?
Sign up at duet.so, point Duet at your business URL, and start with one connected workflow. The first useful output depends on the workflow and tools connected.
---
Source: https://duet.so/vs/replit
# Duet vs Replit: should you build an app or run a business with AI?
Replit wins when you want a browser IDE, fast app generation, and developer-friendly deployment. Duet wins when the app is only one part of a recurring business workflow that needs memory, team context, and an AI coworker to keep operating it.
*Updated 2026-05-19 — Updated for Replit Agent 4 positioning around parallel task execution, app monitoring, and cloud development.*
## Where Replit wins
### Browser IDE and education roots
Replit is excellent if you want a full coding environment in the browser, especially for learning, prototyping, and developer-owned projects.
### Fast app deployment
For a developer who mainly wants to create, run, and deploy an app, Replit’s build surface is more mature and more familiar.
### Developer community and templates
Replit has a large ecosystem around projects, templates, and examples. That matters when the goal is to start from code and learn by remixing.
## Where Duet wins
### Duet treats the app as the beginning
Replit helps you ship the app. Duet helps you run the business process that made the app necessary in the first place.
### The AI coworker remembers the business
Duet’s memory is not just project context. It includes why the app exists, who asked for it, what customers said, and what recurring work should happen next.
### Better for non-technical teammates
Replit is friendlier than traditional dev tools, but it is still a builder. Duet gives operators a shared workspace where AI sessions can explain, ask, approve, and follow through.
### Runs cross-tool workflows
A real business workflow touches email, docs, billing, support, calendars, and CRM. Duet’s workspace is built for that messy operating layer.
## FAQ
### Is Duet a Replit alternative?
Partly. Duet can build and host apps, but it is not mainly a browser IDE. It is a cloud AI coworker workspace for building and running business operations.
### Which is better for beginners?
Replit is better for people learning to code or exploring app development. Duet is better for operators who want to delegate business outcomes.
### Can Duet host apps like Replit?
Yes. Duet can build and host apps from the workspace. The difference is that Duet also runs recurring workflows around those apps.
### Is Replit or Duet better for small business operations?
Replit is a browser IDE and app hosting platform; Duet is shaped around the operating work around the app — customer support, reporting, billing, approvals, memory, and recurring workflows.
### Can I move a Replit project into Duet?
Yes, if you can export or sync the code to a repo. The bigger migration is bringing over the business context and recurring workflows that were outside Replit.
### Does Duet replace a developer?
For many internal SMB tools, it can replace the need to hire a developer for every small workflow. For complex software products, it is better thought of as an AI teammate.
### Which is better for app monitoring?
Replit has strong app-oriented tooling. Duet is better when monitoring needs to trigger business follow-up, reports, approvals, or support workflows.
### Should agencies use Replit or Duet?
Agencies with developer-heavy delivery may still like Replit for building. Agencies selling ongoing client outcomes should look at Duet because the workspace supports client context and recurring operations.
---
Source: https://duet.so/vs/v0
# Duet vs v0: should you generate UI or hire an AI coworker to run the workflow?
v0 wins when you need a beautiful React or Next.js interface quickly. Duet wins when that interface needs to become a live tool connected to business context, hosted in a workspace, and operated repeatedly by an AI coworker.
*Updated 2026-05-19 — Published the v0 comparison for teams deciding between UI generation and persistent AI-operated workspaces.*
## Where v0 wins
### Fast UI exploration
v0 is the right tool when you want to see several interface directions quickly or generate front-end code a developer can refine.
### Vercel-native front-end workflows
If your stack is already Next.js and Vercel, v0 fits naturally into that path and produces code in the shape your front-end team expects.
### Design-to-code focus
v0 is narrower, and that is a strength. It does not try to be your CRM, inbox, scheduler, or operator.
## Where Duet wins
### Duet turns the UI into a working business tool
A generated interface is only useful if it connects to data, gets used by the team, and keeps the workflow moving. Duet owns that broader loop.
### The AI can run what it builds
Duet can build the dashboard and then send the weekly summary, flag exceptions, update records, and ask for approval when something needs a human.
### Context is not trapped in a component prompt
Duet keeps docs, files, session history, customer notes, and past decisions together so the next change starts from business memory.
### Better for operators than front-end specialists
If you are a designer or front-end engineer, v0 is a joy. If you are a business owner trying to make the work happen, Duet is the more complete surface.
## FAQ
### Is Duet a v0 alternative?
Only partly. v0 is a UI generation tool. Duet is a cloud AI coworker workspace that can build apps and run the workflows around them.
### Which is better for UI design?
v0 is better for pure UI design and component generation. Duet is better when the UI needs to become a functioning business workflow.
### Can Duet use code generated by v0?
Yes. If you bring the generated code into a repo or workspace, Duet can help turn it into a hosted tool connected to your business context.
### Does v0 run recurring workflows?
No, not as its core job. v0 generates front-end code. Duet is designed to run recurring workflows, scheduled jobs, and cross-tool business processes.
### Which is better for founders?
If the founder is prototyping a UI, v0 is great. If the founder needs the app to run a real process and keep improving, Duet is the better fit.
### Can Duet generate landing pages?
Yes. Duet can build landing pages and apps, but its advantage is that the same coworker can also update them later and run the operations connected to them.
### Should designers use Duet or v0?
Designers should probably start with v0 for visual exploration. They should use Duet when the design needs to become a live app with operational ownership.
### What is the main difference between Duet and v0?
v0 generates the interface. Duet can generate the interface, host it, remember the business context, and run the workflow the interface exists to support.