# Builder Brief (full content) > A weekly, sourced tracker of AI tool launches, model releases and pricing changes, for people building AI agents and for people using AI at work. Site: https://builderbriefai.com/ | X: https://x.com/builderbriefai | Index: https://builderbriefai.com/llms.txt | Generated: 2026-10-15 Disclosure: some outbound links are affiliate links; picks are not paid placements unless marked featured. Products: AI Playbook for Real Estate Agents ($49 PDF) and Done-With-You AI Setup for Agents ($497), https://builderbriefai.com/real-estate-ai/. Tool makers can list free or buy express review ($49), featured listing ($99/mo) or launch package ($249) at https://builderbriefai.com/submit/. # Playbooks ## Automate inbox triage with n8n and AI URL: https://builderbriefai.com/playbooks/automate-inbox-triage-with-n8n/ Summary: Build an n8n workflow that watches Gmail, classifies each email with an AI Text Classifier, labels it, and drafts replies for routine requests, without auto-sending anything. The average inbox mixes four kinds of mail: things only you can answer, routine requests with a known answer, FYIs, and noise. Sorting them by hand costs knowledge workers hours a week. This playbook builds an [n8n](/tools/n8n/) workflow that does the sorting for you and drafts the routine replies, while leaving every send decision with a human. All node names and options come from the [n8n docs](https://docs.n8n.io/).

Step 1: Define your categories and actions

Before opening n8n, write a short table. The categories should be **mutually exclusive** and each should map to **one action**. A good starting set: | Category | Description for the AI | Action | | --- | --- | --- | | Urgent client | A current client reporting a problem or deadline | Label `AI/Urgent`, alert in Slack | | Sales lead | A new prospect asking about pricing, demos or services | Label `AI/Lead`, log to a sheet or CRM | | Routine request | Scheduling, document requests, simple FAQs | Label `AI/Routine`, create a draft reply | | Newsletter / FYI | Updates, newsletters, notifications | Label `AI/FYI`, mark as read | The description column matters most: n8n's docs note that category descriptions are how you tell the model what each category means.

Step 2: Create Gmail labels

In Gmail, create the labels from your table (an `AI/` prefix keeps them grouped and makes it obvious which labels the robot applied). You can also create labels from n8n with the Gmail node's **Label → Create** operation, but doing it by hand is faster for four labels.

Step 3: Add the Gmail Trigger

Create a new workflow and add a **Gmail Trigger** node. Its event is **Message Received**, checked at the **Poll Times** you choose (every minute up to longer intervals; start with every 5–15 minutes). 1. Under **Credential to connect with**, create a Google credential following n8n's Google credentials guide. On n8n Cloud this is mostly a sign-in-with-Google click; self-hosted instances need a Google Cloud OAuth client. 2. Leave **Simplify** on for now. It returns message IDs, labels and headers (From, To, CC, BCC, Subject). For the email body you'll want it off, or add a Gmail **Message → Get** node afterwards. 3. Under filters, set **Read Status** to *Unread emails only* (the default) and use **Search** to exclude noise, e.g. `-category:promotions`. 4. **Max Emails per Poll** defaults to 10 (maximum 50); extra emails queue for the next poll. Click **Fetch Test Event** to pull a real message and confirm the fields you'll need (subject, from, text).

Step 4: Add the Text Classifier and a chat model

Add the **Text Classifier** node (in n8n's AI nodes). Configure: - **Input Prompt:** an expression combining the fields, for example `From: {{ $json.from }} Subject: {{ $json.subject }} Body: {{ $json.text }}` (field names depend on your trigger settings; use the fields you saw in the test event). - **Categories:** add your four categories with their descriptions from Step 1. - Options: keep **Allow Multiple Classes To Be True** off so each email gets exactly one action. Set **When No Clear Match** to **Output on Extra, 'Other' Branch**. The default is to *discard* the item, which would silently drop emails. - Optionally turn on **Enable Auto-Fixing**, which sends parsing errors back to the model to correct its output format. The classifier needs a **chat model sub-node**: connect an OpenAI, Anthropic or other model credential, or an Ollama model if you self-host and want email text to stay on your server. A small, cheap model is usually enough for classification.

Step 5: Route each category to an action

The Text Classifier has one output per category (plus Other). Wire each: - **Urgent client →** Gmail **Message → Add Label** (`AI/Urgent`) → a Slack node posting the subject and sender to your alerts channel. - **Sales lead →** Add Label (`AI/Lead`) → a Google Sheets or CRM node appending sender, subject and date. - **Routine →** Add Label (`AI/Routine`) → the drafting branch in Step 6. - **FYI →** Add Label (`AI/FYI`) → Gmail **Message → Mark as Read**. - **Other →** Add Label `AI/Review` so a human looks at it. Use the message ID from the trigger in each Gmail node's Message ID field.

Step 6: Draft replies for routine requests

On the Routine branch add a chat-model step (for example the **Basic LLM Chain** node or your provider's node) with a prompt like: > You draft short, friendly email replies for [Company]. Use only the facts below. If the request needs information not listed, write "NEEDS HUMAN:" followed by what's missing. > Facts: office hours 9–5 MT; booking link: [your link]; invoices are sent on the 1st; documents are shared via [portal]. > Email: {{ subject }} / {{ body }} Then add a Gmail **Draft → Create** node using the AI text as the body, the original subject prefixed with "Re:", and the sender as recipient. Nothing is sent: you open Gmail, review the draft, and click send. If the draft starts with "NEEDS HUMAN:", route it to `AI/Review` instead using an **If** node.

Step 7: Test with real emails

Forward or star 15–20 real examples covering every category plus a few tricky ones (a client who's also asking about pricing; a newsletter from a client). Run the workflow manually and record the predicted category versus the right one. If accuracy is below ~90%: - Sharpen the category descriptions (add "includes…" and "does not include…"). - Give the classifier more context, such as a list of your client domains. - Try a stronger model for this one node.

Step 8: Activate and monitor

Toggle the workflow **Active**. For the first week, check the `AI/` labels daily and n8n's **Executions** list for errors. Keep a note of misclassifications and update the descriptions weekly. Once the drafts are consistently good you'll find you're just reviewing and clicking send. ## Pitfalls - **Leaving "When No Clear Match" on Discard.** Unclassified mail vanishes from your workflow. Always use the Other branch. - **Auto-sending.** One hallucinated price or date to a client costs more than all the time saved. Draft, don't send. - **Classifying with headers only.** With Simplify on, you may not have the body. Fetch it. - **Polling too often on a small plan.** Each poll is an execution; on n8n Cloud, executions count toward plan limits. - **Privacy blind spots.** Email often contains personal or client-confidential data. Check your AI provider's data-use terms, or self-host with [Ollama](/tools/ollama/). - **Overlapping categories.** "Urgent" and "Client" as separate classes will fight each other. Make classes exclusive. ## Alternatives Prefer a hosted, less technical builder? The same pattern works in [Make](/tools/make/) (Gmail watch → AI module → router) or [Zapier Agents](/tools/zapier-agents/). If you just want a faster inbox with built-in AI rather than an automation, see [Superhuman](/tools/superhuman/). Compare the builders in [n8n vs Make](/compare/n8n-vs-make/). --- ## Turn a blog post into a video with HeyGen and Descript URL: https://builderbriefai.com/playbooks/blog-post-to-video-heygen-descript/ Summary: Repurpose one written article into a talking-avatar explainer and short social clips: script it with an AI assistant, generate the presenter in HeyGen, then polish, caption and cut clips in Descript. You spent hours on a great article. A video version reaches people who will never read 1,500 words, and short clips feed every social channel for a week. This playbook converts one post into a 2–4 minute avatar explainer with [HeyGen](/tools/heygen/), then polishes it and cuts clips in [Descript](/tools/descript/).

Step 1: Pick the post and the video's single job

Not every post converts well. The best candidates are **how-to, list, or opinion posts with a clear takeaway**. Data-dense posts with big tables don't. Then decide the video's one job, e.g. "get viewers to download the checklist" or "explain why X matters in 3 minutes." Everything in the script serves that job.

Step 2: Turn the article into a spoken script

Written and spoken language differ: speech needs shorter sentences, signposting ("first… second…") and a hook in the first five seconds. Paste the article into [ChatGPT](/tools/chatgpt/) or [Claude](/tools/claude/) with a prompt like: > Rewrite this article as a script for a 3-minute talking-head video (about 450 words). Open with a one-sentence hook that states the problem. Use short sentences. Split it into 6–8 scenes, each with: SCENE number, SPOKEN TEXT, and ON-SCREEN (a short caption, screenshot idea or B-roll idea). End with one call to action: [your CTA]. Don't add facts that aren't in the article. Read the script **out loud**. Anything you stumble over, rewrite. Check names, numbers and claims against the original. AI rewriting can quietly change facts.

Step 3: Choose an avatar and voice in HeyGen

In HeyGen you can use a stock avatar or create your own. HeyGen's site describes creating an avatar from video (a "digital twin") or from a single clear, front-facing photo, plus instant voice cloning from one recording. For a brand channel: - **Stock avatar + stock voice:** fastest, no recording needed. - **Your own avatar:** more authentic and better for founder-led brands. Follow HeyGen's recording guidance (steady camera, even lighting, quiet room) and complete its consent step. Pick a voice that matches the tone of your writing, and set pronunciation for brand names if they're mispronounced.

Step 4: Build scenes in HeyGen AI Studio

Open **AI Studio** and create a new video. For each scene from your script: 1. Paste the SPOKEN TEXT as the avatar's script. 2. Add the ON-SCREEN element: a text overlay, screenshot or your own footage. HeyGen says you can drop in your own footage as the background, remove the avatar's background, and position the avatar anywhere in the scene. 3. Keep layouts consistent: same avatar position, same caption style, brand colors. Have slides already? HeyGen also lets you upload a PowerPoint or PDF (up to 50 slides) so the avatar presents each slide picture-in-picture, optionally using your speaker notes as the script. That's a fast path if the post started as a talk. Save the project as a **template** once it looks right, so your next post takes minutes.

Step 5: Generate and review the video

Submit the video for rendering. While you wait, prepare a checklist and then review the output: - Do any words sound wrong (names, acronyms, numbers)? Fix with phonetic spelling or pronunciation settings and re-render that scene. - Does lip-sync look natural at the start and end of scenes? - Is every on-screen claim accurate? Download the MP4 at the highest resolution your plan allows.

Step 6: Polish in Descript

Import the MP4 into a new Descript project. Descript transcribes it and lets you **edit the video by editing the text**: delete a sentence in the transcript and it's cut from the video. - Tighten pacing: remove dead air and any repeated lines. - Add **captions** (most social video is watched muted) in your brand font. - Layer in B-roll, screenshots or [Canva](/tools/canva/) graphics on top of the relevant lines. - Add intro/outro cards and background music at a low level. - Use Descript's AI assistant, **Underlord**, for chores like suggesting clips, or its tools like Remove Filler Words and Studio Sound when you mix in real recordings. Export a 16:9 version for YouTube and your blog.

Step 7: Cut short clips for social

Find the 3–5 strongest 30–60 second moments (a surprising stat, a crisp tip, the hook). In Descript, duplicate the composition, delete everything else from the transcript, switch the layout to **9:16** vertical, and reframe so the avatar and captions fit. Each clip should make sense without context and end with a pointer to the full video or post.

Step 8: Publish and measure

- **Embed the full video at the top of the original blog post.** It increases time on page and gives search engines another asset. - Upload to YouTube with a keyword-rich title, a description that links the post, and chapters matching your scenes. - Post clips to LinkedIn, X, Instagram and TikTok across the week. - Track views, average watch time and clicks to the CTA. If people drop in the first 10 seconds, rewrite the hook next time. ## Pitfalls - **Pasting the article as-is.** Written prose sounds stiff when spoken. Always rewrite for the ear. - **Uncanny over-length.** Long avatar monologues lose viewers. Cut scenes to 20–40 seconds and vary visuals. - **Mispronunciations.** Proofread by listening, not reading. - **Likeness and consent.** Never create an avatar or voice clone of someone without their explicit permission. - **Undisclosed AI.** Label synthetic presenters where platforms require it; it's also good practice. - **Credit surprises.** Both tools meter usage. Check your plan's limits before batch-producing. ## Alternatives [Synthesia](/tools/synthesia/) is HeyGen's closest competitor and popular for corporate training (see [HeyGen vs Synthesia](/compare/heygen-vs-synthesia/)). For voice-only versions (a podcast or audio article), generate narration with [ElevenLabs](/tools/elevenlabs/) and edit it in Descript. ## A reusable production template Once your first video works, save these so the next one takes under an hour: 1. **Script prompt** (Step 2) saved in a doc, with your CTA and banned phrases. 2. **HeyGen template** with avatar, layout, caption style and intro/outro scenes. 3. **Descript template** with brand fonts, caption style, music bed and lower-thirds. 4. **Clip checklist:** hook in the first 3 seconds, captions on, 9:16, ends with a pointer. 5. **Publishing checklist:** embed on the post, YouTube title/description/chapters, clip schedule. ## Example scene plan For a post titled "5 mistakes teams make with AI meeting notes," the scene plan might be: (1) hook: "Your AI notetaker might be creating more work, not less"; (2–6) one scene per mistake with an on-screen caption naming it; (7) the fix in one sentence; (8) CTA: "Grab the full checklist on our blog." Eight scenes of 20–25 seconds each lands at roughly three minutes, and each mistake scene doubles as a standalone social clip. --- ## Your first AI agent with the OpenAI Agents SDK in 30 minutes URL: https://builderbriefai.com/playbooks/first-ai-agent-openai-agents-sdk/ Summary: Build a working Python agent with tools and handoffs using the OpenAI Agents SDK, then inspect it in the trace viewer. Every command checked against the official quickstart. Most "AI agent" tutorials stop at a chatbot. This playbook gets you to the three things that make an agent useful: it can **call your code (tools)**, it can **route work to specialists (handoffs)**, and you can **see exactly what happened (traces)**. We follow the official [OpenAI Agents SDK quickstart](https://openai.github.io/openai-agents-python/quickstart/) and extend it into a small but realistic project: a support triage agent for a fictional SaaS product. ## What you'll build A `triage` agent that reads a customer message and hands it to either a **Billing** specialist or a **Technical** specialist. The technical specialist can call a Python function that looks up a (fake) service status. At the end you'll have a ~60-line script you can adapt to your own business: swap the fake function for a real API call and you have the bones of a production agent.

Step 1: Create a project and virtual environment

A virtual environment keeps the SDK and its dependencies isolated from the rest of your machine. You only do this once per project: ```bash mkdir triage-agent cd triage-agent python -m venv .venv source .venv/bin/activate # macOS / Linux # .venv\Scripts\activate # Windows ``` Every time you open a new terminal, re-run the activate line. If your prompt shows `(.venv)`, you're in.

Step 2: Install the SDK and set your API key

```bash pip install openai-agents export OPENAI_API_KEY=sk-... # macOS / Linux # $env:OPENAI_API_KEY = "sk-..." # Windows PowerShell ``` Create the key in the OpenAI platform dashboard under API keys. Note that a ChatGPT subscription is **not** the same thing as API access: API usage is billed separately, so add a payment method and, ideally, a monthly usage limit before you start experimenting.

Step 3: Define and run a single agent

An agent is a name, instructions, and optional configuration such as a model. `Runner.run` executes it and returns a result object whose `final_output` holds the answer. Create `main.py`: ```python import asyncio from agents import Agent, Runner agent = Agent( name="Support Assistant", instructions="You answer questions about Acme App clearly and briefly.", ) async def main(): result = await Runner.run(agent, "How do I reset my password?") print(result.final_output) if __name__ == "__main__": asyncio.run(main()) ``` Run `python main.py`. You should see a short answer. Congratulations, that's an agent, though not a very capable one yet. It has no access to real data, so anything it says about "Acme App" is made up. That's the problem tools solve.

Step 4: Give the agent a tool

Tools are ordinary Python functions the model can choose to call. The SDK reads the function's name, type hints and docstring to describe it to the model, so write the docstring as if you're explaining the function to a new teammate. The SDK exposes a `function_tool` decorator (current docs also show `tool` from `agents.decorators`; both are available in version 0.24): ```python from agents import Agent, Runner, function_tool @function_tool def service_status(region: str) -> str: """Return the current status of Acme App in a region such as 'us' or 'eu'.""" fake = {"us": "operational", "eu": "degraded: login latency"} return fake.get(region.lower(), "unknown region") ``` Then pass it to an agent with `tools=[service_status]`. When a user writes "Login is slow in Europe, is something wrong?", the model can decide to call `service_status("eu")` and ground its answer in the result. In real life this function would call your status page API, database or CRM. Keep tools **narrow** (one job each) and **safe** (read-only first; add write actions only once you trust the flow).

Step 5: Add specialist agents and handoffs

The SDK documents two multi-agent patterns. **Handoffs** let a specialist take over the conversation; **agents as tools** keep an orchestrator in charge. We'll use handoffs, as the quickstart does. `handoff_description` tells the routing agent when to delegate: ```python billing = Agent( name="Billing", handoff_description="Questions about invoices, refunds, plans and payment methods", instructions="You handle billing questions. Never promise refunds; explain the policy and offer to escalate.", ) technical = Agent( name="Technical", handoff_description="Bugs, outages, login problems and how-to questions", instructions="Diagnose technical issues. Check service_status before blaming the user.", tools=[service_status], ) triage = Agent( name="Triage", instructions="Route each customer message to the right specialist.", handoffs=[billing, technical], ) async def main(): result = await Runner.run(triage, "Login is super slow for our team in Germany today.") print(result.final_output) print("Answered by:", result.last_agent.name) ``` `result.last_agent.name` tells you which specialist finished the job: a cheap but very useful assertion for tests. Try five or six different messages (a refund request, a feature question, an ambiguous one) and check that routing behaves.

Step 6: Inspect traces

Open the **Trace viewer** in the OpenAI Dashboard. Each run shows the triage call, the handoff, the tool call with its arguments and output, and the final answer. This is where you debug: if the agent routed wrongly, read what the triage agent saw and tighten its instructions or the `handoff_description` text. If you want vendor-neutral observability across frameworks, tools like [LangSmith](/tools/langsmith/) also ingest agent traces.

Step 7: Add conversation memory

A single `Runner.run` call is one turn. For a second turn the quickstart lists three options: 1. **Manual:** pass `result.to_input_list()` plus the new user message back into `Runner.run`. Full control, provider-agnostic. 2. **Sessions:** pass `session=...` and let the SDK load and save history for you. 3. **Server-managed:** reuse OpenAI-side state with `previous_response_id` or `conversation_id`. For a prototype, sessions are the least code. For anything where you must control retention (customer data!), the manual approach makes it obvious what you store and where.

Step 8: Harden it before sharing

Before anyone else uses your agent: - **Add guardrails.** The SDK supports input and output guardrails that run checks alongside the agent; use them to block off-topic requests or to stop the billing agent from inventing refund amounts. - **Write a tiny eval set.** Ten real customer messages with the expected specialist. Run them after every prompt change and compare `last_agent.name`. - **Cap spend.** Set a usage limit in your OpenAI account and log token usage per run. - **Keep secrets out of code.** Load the API key from the environment, never commit it. ## Pitfalls - **Treating a ChatGPT plan as API credit.** They're billed separately; your script will fail with an auth or quota error until API billing is set up. - **Vague docstrings.** The model only knows what a tool does from its name, types and docstring. "Gets data" is useless; "Return open invoices for a customer email" works. - **Too many tools on one agent.** Accuracy drops as you pile on tools. Split into specialists and route. - **Forgetting the venv.** "ModuleNotFoundError: agents" almost always means you opened a new terminal and didn't re-activate `.venv`. - **Name collision.** The package installs as `openai-agents` but imports as `agents`. Don't name your own file `agents.py`, or Python will import it instead. - **Shipping write-tools on day one.** Let the agent read before it can refund, delete or email. ## Where to go next Compare the SDK with [LangGraph](/tools/langgraph/) if you need explicit state machines, or [Pydantic AI](/tools/pydantic-ai/) if structured, validated outputs matter most. If you want to give the agent access to tools other people have already built, read our [MCP servers playbook](/playbooks/mcp-servers-for-claude/): MCP is supported across many agent frameworks. And when you're ready to run models privately, see [Run local models with Ollama](/playbooks/run-local-models-with-ollama/). --- ## Set up MCP servers for Claude (Desktop and Claude Code) URL: https://builderbriefai.com/playbooks/mcp-servers-for-claude/ Summary: Connect Claude to your files, Notion, GitHub and other tools with the Model Context Protocol. Exact config paths and commands from the official MCP and Claude Code docs. The [Model Context Protocol](/tools/mcp/) (MCP) is the closest thing AI has to a USB port: one standard way to plug tools and data into an assistant. Instead of pasting a spreadsheet into Claude, you connect a server once and Claude can read (and, with permission, act on) the real thing. This playbook covers both the no-code path in [Claude](/tools/claude/) Desktop and the developer path in [Claude Code](/tools/claude-code/), using the official [MCP user quickstart](https://modelcontextprotocol.io/quickstart/user) and the [Claude Code MCP reference](https://code.claude.com/docs/en/mcp).

Step 1: Decide what Claude should reach

Start from a pain, not a server list. The Claude Code docs put it well: connect a server when you find yourself copying data into chat from another tool. Good first candidates: - **A folder of documents** (contracts, notes, exports) → Filesystem server. - **Your wiki or task tracker** (Notion, Asana, Linear) → the vendor's remote MCP server. - **Your codebase's surrounding systems** (GitHub issues, Sentry, a Postgres database) → for developers in Claude Code. Write down the one task you want to stop doing manually, e.g. "summarize every PDF in my Contracts folder into a table." You'll test against that.

Step 2: Install Node.js

Many MCP servers, including the Filesystem server, run through Node's `npx`. In a terminal: ```bash node --version ``` If that errors, install the **LTS** version from nodejs.org, then reopen the terminal and check again.

Step 3: Open the Claude Desktop config

In Claude Desktop, open the **Claude menu in your system menu bar** (not the settings inside the chat window) → **Settings…** → **Developer** tab → **Edit Config**. This creates the file if needed. It lives at: - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json` - Windows: `%APPDATA%\Claude\claude_desktop_config.json`

Step 4: Add the Filesystem server

Replace the file's contents with this, swapping `username` for your real username and listing only folders you're comfortable with Claude reading and modifying: ```json { "mcpServers": { "filesystem": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-filesystem", "/Users/username/Desktop", "/Users/username/Downloads" ] } } } ``` On Windows, use paths like `"C:\\Users\\username\\Desktop"` (double backslashes inside JSON). The `-y` flag lets npx install the package without prompting; everything after the package name is the list of allowed directories. Paths must be **absolute**. Security note from the official guide: the server runs with *your* account's permissions, so it can do anything you can do in those folders. Point it at a dedicated working folder rather than your whole home directory.

Step 5: Restart and verify the connector

Fully **quit** Claude Desktop (not just close the window) and reopen it. Then click the **"Add files, connectors, and more /"** indicator at the bottom-left of the message box, hover **Connectors**, click **Manage connectors**, and select **filesystem** to see its tools. Now test with your Step 1 task, for example: *"List the PDFs in my Downloads folder and make a table of file name, date and a one-line summary."* Claude will ask for approval before each file operation. Read those prompts; that approval is your safety net.

Step 6: Add a remote server in Claude Code

Developers can connect servers from the terminal. Remote **HTTP** servers are the recommended transport: ```bash # Basic syntax claude mcp add --transport http # Real example from the docs: Notion claude mcp add --transport http notion https://mcp.notion.com/mcp # With a bearer token claude mcp add --transport http secure-api https://api.example.com/mcp \ --header "Authorization: Bearer your-token" ``` The SSE transport is deprecated; use it only for services that still expose nothing else. Browse reviewed connectors in the Anthropic Directory (claude.ai/directory); remote servers listed there can be added the same way. Then ask Claude Code something that needs the server: *"Read the spec page for the onboarding redesign in Notion and list the open questions."*

Step 7: Share project servers with your team

Claude Code reads server definitions from JSON as well as the CLI, including a project-level `.mcp.json`. Committing that file lets teammates get the same servers when they open the repo. Two gotchas from the docs: - An entry with a `url` but **no `type`** is treated as a stdio server and skipped with an error. Always set `"type": "http"` (`streamable-http` is accepted as an alias). - Never commit tokens. Keep secrets in environment variables or each person's local config.

Step 8: Troubleshoot with logs

If a server doesn't appear: 1. Quit and restart Claude Desktop completely. 2. Validate the JSON (a single missing comma breaks it). 3. Confirm every path is absolute and exists. 4. Run the server by hand to see errors: `npx -y @modelcontextprotocol/server-filesystem /Users/username/Desktop`. 5. Read the logs: macOS `~/Library/Logs/Claude`, Windows `%APPDATA%\Claude\logs`. `mcp.log` covers connections; `mcp-server-SERVERNAME.log` holds each server's stderr. On Windows, if logs mention `${APPDATA}`, add the expanded `APPDATA` path to the server's `env` block, and make sure npm is installed globally (`npm install -g npm`). ## Pitfalls - **Granting your whole drive.** Scope folders tightly; you can always add more. - **Editing the in-app settings instead of the menu-bar Settings.** The developer config lives under the system menu bar's Claude → Settings. - **Not fully quitting.** Config is only read at launch. - **Trusting every server.** Third-party servers can be malicious or vulnerable to prompt injection, especially ones that fetch web pages or email. Prefer official vendor servers and directory-reviewed connectors. - **Rubber-stamping approvals.** The per-action approval only protects you if you read it. ## Where to go next The same servers work in other MCP clients such as [Cursor](/tools/cursor/) and [Cline](/tools/cline/). Builders can expose their own product as an MCP server so agents can use it; pair that with our [OpenAI Agents SDK playbook](/playbooks/first-ai-agent-openai-agents-sdk/) to see the agent side. ## Worked example: a contracts folder assistant Here's how a small agency used this setup in under half an hour. They created a dedicated folder, `~/AI-Workspace/Contracts`, copied 30 client agreements into it as PDFs, and pointed the Filesystem server at that folder only. Their first prompt was: > For every PDF in AI-Workspace/Contracts, extract client name, start date, renewal date, notice period and monthly fee. Put the results in a table, then save it as renewals.csv in the same folder. Flag any contract where the notice period ends in the next 60 days. Claude asked for approval to list the folder, read each file and write the CSV. The team checked five rows against the originals (all correct; one fee was ambiguous because the contract had two rates, which Claude flagged). The result replaced a quarterly half-day spreadsheet chore. Their next step was a remote server: they connected their task tracker so Claude could create a "renewal review" task for each flagged contract, still with approval on every action. ## Checklist before you add more servers - Is this server from the vendor itself or a reviewed directory? If not, read its source or skip it. - Does it need write access, or would read-only do? - Where are its credentials stored, and who can see that config file? - Have you tested the one task you added it for? - Do teammates know which servers are connected, and what they can touch? Treat each new server like installing a browser extension with access to your work: useful, but only when you trust it and know what it does. --- ## Meeting notes to CRM: Fireflies + Make + HubSpot URL: https://builderbriefai.com/playbooks/meeting-notes-to-crm-fireflies-make-hubspot/ Summary: Automatically push every sales call's summary and action items into the right HubSpot contact as a note, using Fireflies Webhooks V2, the Fireflies GraphQL API and a Make scenario. The CRM is only as good as what reps put into it, and after a day of back-to-back calls, nobody writes thorough notes. [Fireflies](/tools/fireflies/) already produces a summary and action items for every recorded meeting. This playbook pipes them into [HubSpot](/tools/hubspot-breeze/) automatically with a [Make](/tools/make/) scenario, so every contact record carries the latest conversation. Fireflies details are from its [Webhooks V2](https://docs.fireflies.ai/graphql-api/webhooks-v2) and [GraphQL API](https://docs.fireflies.ai/) docs. ## How it works 1. Fireflies finishes summarizing a meeting and POSTs `{ "event": "meeting.summarized", "meeting_id": "…" }` to a Make webhook. 2. Make calls the Fireflies GraphQL API for that meeting's title, date, attendees, overview and action items. 3. Make finds each external attendee in HubSpot by email. 4. Make creates a note (and optionally tasks) on that contact.

Step 1: Map what should land in the CRM

Decide the note format before you build. A useful template: ``` 📞 {title} ({date}, {duration} min) Summary: {overview} Action items: {action_items} Recording: {transcript_url} ``` Agree with the team which meetings count. If you record internal stand-ups too, you'll filter to meetings with at least one attendee outside your company domain (Step 7).

Step 2: Create the Make webhook

In Make, create a new scenario. Add the **Webhooks → Custom webhook** module as the trigger, click **Add**, name it "Fireflies summarized", and copy the generated HTTPS URL. Leave the scenario open with **Run once** active so Make can learn the payload structure from the first delivery.

Step 3: Subscribe Fireflies Webhooks V2

Open the Fireflies **Webhooks V2** configuration page (app.fireflies.ai/integrations/api/webhook): 1. Paste the Make URL into **Webhook URL**. 2. Optionally set a **Signing Secret** for payload signature verification (recommended once it works). 3. Under **Event Subscriptions**, select **meeting.summarized**. 4. Save, then click **Send Test Event**. Make should show a received bundle with `event`, `timestamp` and `meeting_id`. Note: webhooks fire for meetings **you own**. On Enterprise teams a Super Admin webhook can receive the team's meetings; otherwise each rep sets up their own.

Step 4: Fetch the transcript summary with GraphQL

Add an **HTTP → Make a request** module: - URL: `https://api.fireflies.ai/graphql` - Method: `POST` - Headers: `Authorization: Bearer YOUR_FIREFLIES_API_KEY`, `Content-Type: application/json` - Body type: Raw, JSON, with this content (map `meeting_id` from the webhook): ```json { "query": "query Transcript($id: String!) { transcript(id: $id) { id title date duration transcript_url meeting_attendees { displayName email name } summary { overview action_items } } }", "variables": { "id": "{{1.meeting_id}}" } } ``` Turn on **Parse response**. Run once with your test meeting and check that `data.transcript.summary.overview` has text. Store the API key in a Make connection or variable rather than typing it into many modules.

Step 5: Find the HubSpot contact

Add an **Iterator** over `meeting_attendees` so each attendee is processed separately. Then a **Filter** that skips your own domain (email *does not contain* `@yourcompany.com`). Next, add the **HubSpot CRM** module that searches contacts (search by the `email` property) and connect your HubSpot account. Map the attendee's email. If HubSpot returns a contact ID you continue; if not, see Step 7.

Step 6: Create the note and tasks

Add a HubSpot module that creates an engagement or **note**, associated with the contact ID found above. Map the body using your Step 1 template. Fireflies returns `action_items` as text, so it drops straight in. Optional: create a HubSpot **task** due in two business days titled "Follow up: {title}" for the deal owner. That single task is often worth more than the note, because it puts the follow-up on a calendar. If a deal is associated with the contact, you can also associate the note with the deal so it shows on both records.

Step 7: Handle unknown attendees and errors

Real meetings are messy. Add branches with a **Router**: - **Contact not found:** either create the contact (only if your team wants that; it can pollute the CRM) or send a Slack/email notification "New attendee {email} from meeting {title}: add to CRM?" - **Internal-only meetings:** if the iterator finds no external attendees, stop. - **Empty summary:** occasionally summaries change after first delivery. Fireflies' optional **Resend when a meeting's notes change** setting will re-send `meeting.summarized`; if you enable it, search for an existing note first so you don't post duplicates. - **Errors:** add an error handler on the HTTP module (Make's **Break** directive retries later) so a temporary API failure doesn't lose the meeting.

Step 8: Test end-to-end and roll out

Record a 5-minute test call with a colleague using an external email that exists in HubSpot. Wait for Fireflies to summarize it, then confirm: 1. Make received the webhook. 2. The GraphQL response has a summary. 3. The note appears on the right contact, formatted correctly. Turn the scenario **ON**, set scheduling to "Immediately" (webhook-triggered), and add the signing secret. Roll out rep by rep, and ask each person to check their first five notes. ## Pitfalls - **Using Webhooks V1 docs from old tutorials.** V1 is deprecated and its settings field is read-only. Use V2. - **Triggering on meeting.transcribed.** The summary may not exist yet. Use meeting.summarized. - **Hard-coding the API key in many modules.** Rotate-ability matters; centralize it. - **Pushing confidential calls into a shared CRM.** Exclude HR, legal and board meetings by title keyword or calendar. - **Consent.** Recording laws differ by location; many require all-party consent. Make sure your Fireflies settings and meeting invites disclose recording. - **Duplicates.** Retries and resends happen. Use the meeting ID in the note text and check for it before creating. ## Alternatives Don't use Fireflies? [Fathom](/tools/fathom/) and [Otter](/tools/otter/) are popular notetakers with their own CRM integrations. Some teams skip the custom build and use a notetaker's native HubSpot sync; it's faster to set up but you lose control over format and filtering. Prefer self-hosting? Rebuild the same flow in [n8n](/tools/n8n/) with a Webhook node, an HTTP Request node and the HubSpot node. See [Otter vs Fireflies](/compare/otter-vs-fireflies/). ## What a good note looks like After the scenario has run for a week, a typical contact record shows a note like this: ``` 📞 Acme <> YourCo: pricing follow-up (Oct 12, 32 min) Summary: Dana confirmed budget approval for Q1 and wants a security review before signing. Main concern is SSO support. Action items: - Send SOC 2 report and SSO docs (you) - Dana to loop in IT lead Sam for review call - Schedule review call week of Oct 20 Recording: https://app.fireflies.ai/view/... ``` Reps stop writing notes, managers see real context in pipeline reviews, and anyone picking up the account later can read the history in a minute. ## Measuring whether it worked Pick two numbers before launch and check them after a month: 1. **Percentage of external meetings with a CRM note** (pull meetings from Fireflies, notes from HubSpot). Teams typically go from patchy coverage to nearly all. 2. **Follow-up speed:** the time from meeting to the first follow-up email or task completion. If coverage is high but follow-ups don't improve, the tasks in Step 6 need owners and due dates that reps actually see. If notes are ignored, shorten them: the overview plus action items is usually enough. --- ## Prospect research with Clay + Apollo URL: https://builderbriefai.com/playbooks/prospect-research-clay-apollo/ Summary: Build a targeted prospect list in Apollo, enrich and research it in Clay with waterfall enrichment and AI research agents, write a personalized first line per lead, and send it back for outreach. Generic outbound gets ignored. What works is a tight list of the right companies, reached at the right moment, with a first line that proves you did your homework. Doing that by hand takes 10–15 minutes per lead. This playbook combines [Apollo](/tools/apollo/) (contact database and sequencing) with [Clay](/tools/clay/) (multi-provider enrichment plus AI research) to do it for hundreds of leads in an afternoon.

Step 1: Write your ideal customer profile

Be specific. A weak profile is "SaaS companies." A strong one: - **Company:** B2B SaaS, 20–200 employees, US/Canada, has a public pricing page. - **Trigger:** hiring for customer support roles (signals support volume growing). - **Persona:** Head of Support, VP Customer Success, or COO at smaller companies. - **Pain you solve:** support ticket backlog; **proof:** one customer result you can cite. Triggers matter most. A company that's hiring, just raised, launched a product or changed tools is far more likely to reply.

Step 2: Build the list in Apollo

In Apollo's **People** search, apply your filters: job titles (include variations like "Head of Support", "Director, Customer Support"), seniority, company headcount, location and industry keywords. Apollo also offers company-level filters, including signals such as job postings on some plans; use what your plan includes. Review the first 50 results manually. If more than a few are wrong-fit, tighten the filters before exporting. Save the search, then export people (name, title, company, domain, LinkedIn URL) as CSV, or save them to a list. Exports and email reveals consume Apollo credits, so export only what you'll work.

Step 3: Import into a Clay table

In Clay, create a new workbook/table and import your CSV. Each row is a person; each column is a field. From here, every enrichment is a new column that runs per row. Before running anything at scale, **filter the table to 10–20 rows** to test. Clay bills enrichment and AI steps in credits, so testing small protects your budget.

Step 4: Enrich with waterfall providers

Add enrichment columns for what Apollo didn't give you or what you want to verify: - **Work email (waterfall):** Clay queries multiple providers in sequence until one finds a result, which typically raises coverage over any single source. Add an email-verification step after it. - **Company data:** headcount, funding, tech stack, location, from the company domain. - **Job postings or news:** to confirm your trigger. Look at the test rows. Are emails found for most? Are company facts right? Adjust providers before scaling.

Step 5: Research each account with an AI column

This is the step that replaces manual research. Add a **Claygent** (Clay's AI research agent) or AI column with a narrow, checkable prompt, for example: > Visit {{company domain}}. In one sentence, describe what the company sells and to whom. Then state whether they currently list open customer support roles on their careers page (Yes/No) and give the URL. If you cannot find it, answer "Unknown". Do not guess. Narrow prompts with "Unknown" as an allowed answer reduce invented facts. Spot-check 10 rows by clicking the URLs. For deeper account research on a short list, a manual pass with [Perplexity](/tools/perplexity/) is still useful.

Step 6: Score and filter

Add a formula or AI column that scores fit, e.g. +2 if hiring support, +1 if 50–200 employees, +1 if they use a tool you integrate with, −3 if they're a competitor or existing customer. Filter to the top tier. It's better to send 80 great emails than 400 mediocre ones; it also protects your sending domain's reputation.

Step 7: Write a personalized first line

Add an AI column (using an OpenAI or Anthropic model through Clay) that writes **only the first line**, grounded in the research columns: > Using only the facts provided, write one natural sentence (max 25 words) to open a cold email to {{first name}}, {{title}} at {{company}}. Reference: {{research summary}} and {{support hiring}}. No flattery, no exclamation marks, don't mention AI or research. If facts are "Unknown", return an empty string. Keep the rest of the email human-written and consistent: problem, proof, one low-friction ask. Read 20 generated lines; reject the pattern if any feel creepy or wrong.

Step 8: Push to your sequence and CRM

Export the final rows (with the first-line column) to CSV and import into an Apollo sequence, mapping the first line to a custom field used in your email template, or use Clay's own integrations to send rows to your outreach tool or CRM such as [HubSpot](/tools/hubspot-breeze/). Log every contacted person in your CRM so you don't email them twice from different tools. Start with a small batch, watch bounce and reply rates for a few days, then scale. ## Pitfalls - **Running enrichment on the whole table first.** Test on 10–20 rows; credits go fast. - **Unverified emails.** High bounce rates damage your domain. Verify before sending. - **AI-invented facts.** Always allow "Unknown" and spot-check. - **Creepy personalization.** Reference business facts, not personal social posts. - **Compliance.** Follow CAN-SPAM in the US (honest headers, physical address, opt-out), and check GDPR, CASL and others for non-US contacts. Not legal advice. - **Sending from your main domain at volume.** Many teams use a separate, warmed-up sending domain. ## Alternatives Want an always-on agent that does research and follow-ups for you? Look at [Lindy](/tools/lindy/). For more tools by sales stage, see [Best AI tools for sales](/best/ai-tools-for-sales/). ## A complete example email Putting it together for one row (fictional company): > **Subject:** Support hiring at Northwind > > Hi Priya, saw Northwind is hiring three support specialists while rolling out the new self-serve plan. > > Teams at that stage usually find ticket volume grows faster than headcount. We help B2B SaaS support teams deflect repetitive tickets; one customer cut first-response time by about half in a quarter. > > Worth a 15-minute look at how that would work with your current helpdesk? > > Alex > YourCo · 123 Main St, Anytown, USA · Reply "no thanks" and I won't follow up The first line came from Clay; everything else is a template. The proof point must be true and verifiable for your own business. Never let AI invent customer results. ## Weekly operating rhythm - **Monday:** refresh the Apollo search for new matches; import only new rows into Clay. - **Tuesday:** run enrichment and research on the new rows; spot-check 10. - **Wednesday–Thursday:** send in small daily batches. - **Friday:** review replies, bounces and unsubscribes; tweak the profile and first-line prompt. Track reply rate by segment, not overall. If one title or industry consistently replies more, narrow the list toward it. --- ## Run local AI models with Ollama (and use them from your code) URL: https://builderbriefai.com/playbooks/run-local-models-with-ollama/ Summary: Install Ollama, pull an open model, chat with it, call it over the REST and OpenAI-compatible APIs, and customize it with a Modelfile. Commands verified against the official Ollama docs. Cloud models are brilliant, but every prompt leaves your machine and every token costs money. [Ollama](/tools/ollama/) runs open models locally with one command, then exposes them through an API your apps (and agents) can call. This playbook follows the [Ollama README](https://github.com/ollama/ollama) and [docs.ollama.com](https://docs.ollama.com).

Step 1: Pick the right model size for your machine

Model size (measured in billions of parameters, "B") drives quality, speed and memory use. Rough guidance that holds across hardware: - **8 GB RAM laptops:** stick to small models (a few billion parameters). Fine for summaries and classification. - **16–32 GB RAM or Apple Silicon with unified memory:** mid-size models become comfortable. - **Dedicated GPUs with lots of VRAM:** larger models and longer contexts. Browse [ollama.com/library](https://ollama.com/library); each model page lists available sizes (tags). Start small. You can always pull a bigger tag later, and a fast small model you actually use beats a slow big one you don't.

Step 2: Install Ollama

From the official README: ```bash # macOS and Linux curl -fsSL https://ollama.com/install.sh | sh # Windows (PowerShell) irm https://ollama.com/install.ps1 | iex ``` Manual downloads (a .dmg for Mac, an installer .exe for Windows) and an official Docker image, `ollama/ollama`, are also available. As with any piped install script, read it first if you're cautious.

Step 3: Run and chat with a model

Running `ollama` on its own opens an interactive menu that can run a model or connect Ollama to coding tools. To go straight to a chat, the README's example is: ```bash ollama run gemma4 ``` The first run downloads the model, then drops you into a chat prompt. Try a real task: paste a messy meeting transcript and ask for decisions and action items. Type `/bye` to exit. Useful commands: `ollama list` (installed models), `ollama pull ` (download without chatting), and `ollama rm ` (free disk space).

Step 4: Call the local REST API

While Ollama is running it serves an API on `localhost:11434`: ```bash curl http://localhost:11434/api/chat -d '{ "model": "gemma4", "messages": [{ "role": "user", "content": "Why is the sky blue?" }], "stream": false }' ``` `"stream": false` returns one JSON object instead of a token stream, which is easier for scripts. There are official libraries too: `pip install ollama` for Python and `npm i ollama` for JavaScript: ```python from ollama import chat response = chat(model="gemma4", messages=[{"role": "user", "content": "Summarize: ..."}]) print(response.message.content) ```

Step 5: Use the OpenAI-compatible endpoint

This is the trick that makes Ollama useful for builders: it supports a subset of the OpenAI API, so most code written for OpenAI can switch to local models by changing two lines: ```python from openai import OpenAI client = OpenAI( base_url="http://localhost:11434/v1/", api_key="ollama", # required by the client, ignored by Ollama ) reply = client.chat.completions.create( model="gemma4", messages=[{"role": "user", "content": "Say this is a test"}], ) print(reply.choices[0].message.content) ``` That means frameworks that accept a custom OpenAI base URL can often run against your laptop for development, then against a hosted provider ([OpenRouter](/tools/openrouter/), [Groq](/tools/groq/) or OpenAI) in production. It's a "subset", so test features like tool calling and structured output with your chosen model before relying on them.

Step 6: Customize behavior with a Modelfile

A Modelfile is a small blueprint for a customized model. `FROM` (required) sets the base; `PARAMETER` tunes runtime settings; `SYSTEM` sets a system message. Example for a house-style summarizer: ``` FROM gemma4 PARAMETER temperature 0.2 SYSTEM You summarize internal documents into 5 bullet points, then list action items with owners. Never invent names. ``` Build and run it: ```bash ollama create summarizer -f Modelfile ollama run summarizer ``` Now your team can call `summarizer` by name from any script, with the instructions baked in.

Step 7: Tune context length and networking

Two settings trip up most people: - **Context window.** Ollama's FAQ states the default is 4,096 tokens, roughly a few pages. Long documents get silently truncated. Raise it globally with `OLLAMA_CONTEXT_LENGTH=8192 ollama serve`, inside a chat with `/set parameter num_ctx 8192`, or per API request with `"options": {"num_ctx": 8192}`. Bigger contexts use more memory. - **Network access.** Ollama binds to `127.0.0.1:11434`, so only your machine can reach it. To serve other devices, set `OLLAMA_HOST=0.0.0.0:11434` (the FAQ shows how per OS). Only do this on a trusted network or behind a firewall or reverse proxy with authentication, since the API has no login of its own.

Step 8: Decide what stays local

A practical split many teams use: - **Local:** classifying and tagging, summarizing internal docs, redacting PII before anything goes to the cloud, offline drafts, development and test runs. - **Cloud:** hard reasoning, complex coding, very long contexts, and anything customer-facing where top quality matters. Ollama also offers optional cloud-hosted models through the same tooling; those send data off your machine, so treat them like any cloud provider. ## Pitfalls - **Pulling a model too big for your RAM.** It will crawl or fail. Drop to a smaller tag. - **Forgetting the context limit.** If summaries ignore the end of a document, raise `num_ctx`. - **Exposing port 11434 to the internet.** There's no built-in auth. Keep it on localhost or put it behind a proxy with authentication. - **Assuming full OpenAI parity.** The compatibility layer is a subset; test your exact features. - **Ignoring licenses.** Open models carry their own licenses; check commercial-use terms on each model's page or on [Hugging Face](/tools/hugging-face/). ## Where to go next Plug your local model into an agent: the [OpenAI Agents SDK playbook](/playbooks/first-ai-agent-openai-agents-sdk/) works the same way once you point it at a compatible endpoint. Or use a local model as the classifier in our [n8n inbox triage playbook](/playbooks/automate-inbox-triage-with-n8n/) so email content never leaves your server. ## Worked example: a private document summarizer in 15 lines A consultant wanted to summarize client interview notes without uploading them anywhere. After Step 6 created the `summarizer` model, this script summarizes every `.txt` file in a folder: ```python from pathlib import Path from ollama import chat for f in Path("interviews").glob("*.txt"): text = f.read_text() r = chat( model="summarizer", messages=[{"role": "user", "content": text}], options={"num_ctx": 8192}, ) Path(f.with_suffix(".summary.md")).write_text(r.message.content) print("done:", f.name) ``` The `num_ctx` option matters here: interview notes were longer than the 4,096-token default, and early summaries ignored the second half of each file until it was raised. On a recent laptop, each summary took well under a minute with a small model. Nothing left the machine. ## Choosing between local, hosted open models and frontier APIs | Need | Good fit | | --- | --- | | Data must not leave the device | Ollama locally | | Open models, but fast and without your own hardware | Hosted inference such as Groq, Together AI or OpenRouter | | Best possible reasoning or coding | Frontier APIs (OpenAI, Anthropic, Google) | Many teams use all three: local for development and sensitive preprocessing, hosted open models for cheap high-volume jobs, frontier models for the hardest steps. --- ## Ship an internal tool with Lovable (no engineers required) URL: https://builderbriefai.com/playbooks/ship-an-internal-tool-with-lovable/ Summary: Go from a spreadsheet-and-email process to a working, logged-in internal web app with Lovable: prompt, iterate, add a database and auth with Lovable Cloud or Supabase, test, and publish. Every company has a process that lives in a spreadsheet, three email threads and someone's head: equipment requests, client onboarding checklists, PTO approvals, inventory counts. [Lovable](/tools/lovable/) turns a plain-English description into a working web app with a real backend. This playbook builds a typical example, an **equipment request tracker** (employees request gear, managers approve, ops fulfills), using flows from the [Lovable docs](https://docs.lovable.dev/).

Step 1: Write a one-page spec

AI app builders are only as good as the brief. Spend 15 minutes writing: - **Users and roles:** Employees (submit, see their own requests), Managers (approve/reject their team's requests), Ops (see all approved requests, mark fulfilled). - **Data:** Request = item, reason, cost estimate, requester, manager, status (Submitted → Approved/Rejected → Ordered → Delivered), dates. - **Screens:** "New request" form, "My requests" list, "Approvals" queue, "Fulfillment" board, simple dashboard with counts. - **Rules:** requests over $1,000 need a second approver; only Ops can mark Delivered. - **Out of scope for v1:** integrations, email notifications, purchasing. The out-of-scope list is the most important line. Small first versions ship.

Step 2: Create the project from a prompt

On the Lovable dashboard, paste a condensed version of your spec into the prompt box. Example: > Build an internal equipment request app for a 60-person company. Employees submit requests (item, reason, estimated cost). Managers approve or reject requests from their team. Ops sees approved requests on a board with columns Ordered and Delivered. Include a dashboard with counts by status. Clean, professional design. Lovable builds the first version and shows it in the **preview** on the right, with the chat on the left. Click around. Lovable's docs note every change is saved as a version you can restore, so experiments can't permanently break anything.

Step 3: Iterate one change at a time

The single best habit, straight from Lovable's own guidance: **ask for one change at a time and check the preview after each.** Good prompts are specific about where and what: - "On the New request form, make Estimated cost a currency field and require a reason of at least 20 characters." - "Add a status filter to My requests." - "In the Approvals queue, clicking Reject should require a short comment." Plain-language feel prompts work too ("make it feel less cluttered"). When something breaks, describe what you did, what you expected and what happened, as precisely as a bug report.

Step 4: Add data, sign-in and roles

A real internal tool needs persistent data and logins. You have two backends: - **Lovable Cloud (default):** built in, no extra account, managed from the Cloud view in Lovable, billed through workspace credits. Best for most projects. - **Your own Supabase project:** for teams that want their own Supabase billing, dashboard access, or to reuse an existing project. In the editor open **More → Cloud** and choose **Already have a Supabase project? Connect it here**. A workspace owner or admin must first link the Supabase organization. Decide now: Lovable's docs are explicit that there is **no one-click migration** between the two later. Then prompt for the backend features, one at a time: 1. "Store requests in the database instead of local state." 2. "Add email and password sign-in. Only signed-in users can see the app." 3. "Add roles: employee, manager, ops. Employees only see their own requests; managers see their team's; ops sees everything approved." Ask Lovable to explain the access rules it created and test them (Step 6). Access control is where internal tools leak data. To import existing data, upload your spreadsheet as CSV in the chat and ask Lovable to seed the requests table with it, or ask for an admin-only CSV import page.

Step 5: Point-and-edit the details

For small visual changes, pointing beats describing. Open the preview toolbar, select an element and say what should change, or use **Edit text inline** to change labels and headlines directly with no prompt. This is also cheaper, since you're not spending a full AI request on a typo.

Step 6: Test like a real user

Before anyone sees it: - Click every button and link. - Create three test accounts (one per role) and verify each sees **only** what it should. Try visiting another user's request URL directly. - Toggle the preview to **Mobile view**: people will open the link on phones. - Try bad input: empty fields, a $1,000,000 request, emoji. Report problems precisely: "In Approvals, clicking Approve on a request over $1,000 marks it approved; it should require a second approver."

Step 7: Publish and share

Click **Publish** (top right), edit the suggested `lovable.app` address if you like, and click **Publish** again. The app is live on that address on every plan; paid plans support custom domains. Remember the most common surprise: **the live site is a snapshot.** Later edits appear in the preview immediately but only reach users after **Publish → Publish changes**. Make that part of your routine.

Step 8: Hand off and maintain

- Write a half-page "how this works" doc: roles, statuses, who owns the app. - Keep a changelog in the project chat or a doc, since prompts are your source code now. - If the tool becomes critical, sync it to a repository so a developer can review security and continue in [Cursor](/tools/cursor/) or another editor. ## Pitfalls - **Giant first prompts.** Ten features at once produce ten half-working features. - **Skipping access-control tests.** The UI hiding a button is not the same as the database refusing the request. - **Secrets in front-end code.** API keys belong in the backend (Lovable Cloud or Supabase secrets), never in the page. - **Two Lovable projects on one Supabase project.** The docs warn they overwrite each other's secrets. - **Forgetting to publish changes.** Users see the old snapshot until you do. - **Regulated data.** Don't put patient, payment card or similar regulated data into a prototype without a proper review. ## Alternatives [Bolt](/tools/bolt/) and [v0](/tools/v0/) are close competitors (see [Lovable vs Bolt](/compare/lovable-vs-bolt/)); [Replit](/tools/replit/) suits people who want an IDE and hosting together. If your "app" is really a shared table with forms, [Airtable](/tools/airtable-ai/) may be enough. ## Prompts that worked well for this build - "Before changing anything, list the database tables and access rules you plan to create for roles employee, manager and ops." - "Add an audit log: every status change records who made it and when, visible to ops only." - "Show me which pages a user with role employee can reach and what data each page loads." Asking Lovable to explain its plan before it builds is the cheapest way to catch misunderstandings. # Industry guides ## AI tools for accounting firms and finance teams URL: https://builderbriefai.com/industries/accounting-finance/ Summary: AI for accountants, bookkeepers and finance teams: client communications, spreadsheet analysis, close checklists, meeting notes and automation, with confidentiality and accuracy cautions. ## Top pain points 1. **Document chasing.** Collecting statements and receipts from clients takes repeated reminders. 2. **Month-end and busy-season crunch.** Repetitive reconciliation commentary and checklists pile up. 3. **Explaining numbers.** Clients want plain-language explanations, not spreadsheets. 4. **Advisory notes.** Insights from client meetings rarely get written down systematically. 5. **Talent shortage.** Firms need to do more with the same staff. ## Workflows that work **Variance commentary.** Export a trial balance comparison, remove client identifiers if your policy requires, and ask an assistant to flag the largest variances and draft commentary questions. The accountant investigates and writes the final explanation. **Plain-language client letters.** After you've determined the substance, an assistant turns technical conclusions into a clear client email. **Document-request automation.** A Make scenario sends scheduled reminders for outstanding items tracked in Airtable and marks them received when files arrive. **Advisory meeting notes.** With client consent, a notetaker captures action items, which you file in the engagement record. ## Compliance cautions This is general information, not professional or legal advice. **Confidentiality:** professional codes and laws (for example, rules on taxpayer information in the US) restrict how client data may be disclosed or used; check whether a given AI vendor and plan is permitted. **Accuracy:** AI output may contain calculation or reasoning errors; every number must be verified against source records. **Professional standards:** documentation, review and independence requirements still apply to AI-assisted work. **Security:** use multi-factor authentication and approved accounts only. ## Your first 30 days - **Week 1:** Use an assistant for client-facing explanations of conclusions you have already reached; track edits needed. - **Week 2:** Pilot variance-commentary drafts on de-identified data for one client and compare with your normal process. - **Week 3:** Automate document-request reminders for one service line with Make and a tracking table. - **Week 4:** Write down review and documentation rules for AI-assisted work and train staff before scaling. Keep a simple log of time spent before and after each change. It's the only honest way to know whether a tool is earning its subscription, and it gives you real numbers rather than vendor claims. ## Questions to ask before buying - Do you commit in writing not to train on our data? - Which certifications (such as SOC 2) do you hold? - Can we restrict which staff can upload client files? - What is the data retention period and how is deletion confirmed? If a vendor can't answer these clearly in writing, keep looking. Most tools on this page offer free tiers or trials, so you can test with non-sensitive sample data before committing. ## Common mistakes to avoid - Letting AI do arithmetic you don't re-check against source records. - Uploading full client files when a de-identified extract would do. - Automating client reminders without an easy way for clients to reply or opt out. - Skipping documentation of who reviewed AI-assisted work papers. The pattern behind all of these is the same: AI is a fast first draft and a tireless assistant, but the professional judgment, the accountability and the final review stay with people. --- ## AI tools for construction companies and trades URL: https://builderbriefai.com/industries/construction-trades/ Summary: AI for contractors, builders and trade businesses: estimates and proposals, customer follow-up, job-site notes, safety training content and back-office automation, with safety and contract cautions. ## Top pain points 1. **Slow quotes.** Leads go cold while estimates wait for evenings. 2. **Paperwork.** Proposals, change orders and daily logs pile up. 3. **Customer communication.** Homeowners want updates; crews are busy. 4. **Spec and bid reading.** Long documents hide critical requirements. 5. **Training a multilingual workforce.** ## Workflows that work **Voice note to proposal.** After a site visit, record a voice memo describing the scope; an assistant turns it into a structured proposal with your standard exclusions and terms. You insert quantities and prices and review. **Bid document checklist.** Upload a spec section and ask for a checklist of submittals, materials, testing and schedule requirements with section references. The estimator verifies each line. **Automated customer updates.** When a job's status changes in Airtable or a sheet, Make sends the customer a short, friendly update and the next milestone. **Multilingual safety modules.** Script toolbox talks, review them against applicable regulations, and produce video versions with Synthesia in the languages your crews speak. ## Compliance cautions General information, not legal or safety advice. **Safety regulations** (such as OSHA in the US) govern training and site practices; AI-generated content must be reviewed by a qualified person. **Contracts and change orders** are legally binding; review every AI-drafted term. **Licensing:** stamped drawings and engineered decisions require licensed professionals. **Customer data:** protect addresses, access codes and photos of homes. ## What a day looks like with AI A site visit ends at 3 PM. In the truck, the estimator records a five-minute voice memo describing the scope. By 3:30 an assistant has turned it into a draft proposal with standard exclusions; the estimator adds quantities and prices from the takeoff, reviews every line and sends it before dinner. Meanwhile the lead-routing automation has already acknowledged two new web inquiries and assigned them, and the customer on Elm Street received an automatic update that drywall starts Monday. ## Your first 30 days - **Week 1:** Build a proposal template prompt and use it on your next three quotes, reviewing every price and quantity. - **Week 2:** Set up a lead-routing automation with an instant acknowledgment email. - **Week 3:** Track active jobs in Airtable or a sheet and automate customer status updates. - **Week 4:** Produce one safety toolbox talk video in your crews' languages and have a qualified person review it. Keep a simple log of time spent before and after each change. It's the only honest way to know whether a tool is earning its subscription, and it gives you real numbers rather than vendor claims. ## Questions to ask before buying - Does it work on a phone in the field, including offline? - Can we use our own templates and terms? - Who can see customer addresses and site photos? - Does it integrate with our accounting or estimating software? If a vendor can't answer these clearly in writing, keep looking. Most tools on this page offer free tiers or trials, so you can test with non-sensitive sample data before committing. ## Common mistakes to avoid - Letting AI fill in quantities or prices instead of your takeoffs and supplier quotes. - Sending AI-drafted contract terms without reading every line. - Treating a summarized spec as complete; always check the referenced sections. - Posting job-site photos that reveal customers' addresses, security systems or personal items. The pattern behind all of these is the same: AI is a fast first draft and a tireless assistant, but the professional judgment, the accountability and the final review stay with people. --- ## AI tools for creators, podcasters and media teams URL: https://builderbriefai.com/industries/creators-media/ Summary: AI for YouTubers, podcasters, newsletter writers and media teams: research, scripting, editing, voice, video, thumbnails and repurposing, with copyright, likeness and disclosure cautions. ## Top pain points 1. **Editing time.** Hours of editing per finished hour of content. 2. **Consistency.** Algorithms reward regular publishing. 3. **Repurposing.** Every platform wants a different format. 4. **Research and accuracy.** Mistakes damage credibility. 5. **Reaching new languages.** ## Workflows that work **Record once, publish everywhere.** Record a long-form episode, edit it in Descript, cut clips for shorts, and have an assistant draft the newsletter version and show notes. **Research to script.** Gather sources into NotebookLM, ask for an outline with citations, then write the script in your voice with an assistant as editor. Fact-check claims with Perplexity and the primary sources. **Localization.** Translate top videos with HeyGen or dub audio with ElevenLabs to reach new audiences. **Thumbnail testing.** Generate concepts in Midjourney, finalize in Canva, and test variations. ## Compliance cautions General information, not legal advice. **Copyright:** don't use AI to reproduce copyrighted material; check music and footage licenses. **Likeness and voice:** get written consent to clone anyone. **Disclosure:** platforms like YouTube require labeling realistic altered or synthetic content; sponsorships require clear disclosure. **Accuracy:** AI research tools can be wrong; verify before publishing. ## What a day looks like with AI A creator records a 40-minute interview on Monday. Descript transcribes it and the editor cuts it by editing text, removing filler words in one pass. An assistant drafts show notes, chapter titles and a newsletter summary from the transcript, and the creator rewrites the intro in their own voice. Five vertical clips are cut from the strongest moments and scheduled through the week. Every factual claim in the notes is checked against the guest's sources before publishing. ## Your first 30 days - **Week 1:** Move your editing into a transcript-based editor and time your next episode end to end. - **Week 2:** Create a repurposing checklist: clips, newsletter, show notes, social posts, each with a saved prompt. - **Week 3:** Test a translated or dubbed version of your best-performing video. - **Week 4:** Write a public note on how you use AI and how you fact-check, and link it from your channel or site. Keep a simple log of time spent before and after each change. It's the only honest way to know whether a tool is earning its subscription, and it gives you real numbers rather than vendor claims. ## Questions to ask before buying - Can we monetize outputs under the tool's terms? - How are cloned voices and avatars protected from misuse? - Does it export in the formats and resolutions we need? - Is there a watermark or credit limit on our plan? If a vendor can't answer these clearly in writing, keep looking. Most tools on this page offer free tiers or trials, so you can test with non-sensitive sample data before committing. ## Common mistakes to avoid - Publishing AI research without checking primary sources. - Over-automating until your channel loses the personal voice audiences came for. - Using music, footage or likenesses without the rights to them. - Ignoring platform labeling rules for realistic synthetic content. The pattern behind all of these is the same: AI is a fast first draft and a tireless assistant, but the professional judgment, the accountability and the final review stay with people. --- ## AI tools for customer support and SaaS teams URL: https://builderbriefai.com/industries/customer-support-saas/ Summary: AI for SaaS support and success teams: ticket triage, reply drafting, knowledge base content, voice agents, call notes and internal tools, with privacy and accuracy cautions. ## Top pain points 1. **Ticket volume** grows faster than headcount. 2. **Misrouted tickets** bounce between teams. 3. **Stale knowledge base.** Answers live in agents' heads and old tickets. 4. **Repetitive questions** crowd out complex ones. 5. **Visibility.** Leaders can't see why customers contact support. ## Workflows that work **Triage and routing.** Classify every incoming message by intent and urgency and route it ([playbook](/playbooks/automate-inbox-triage-with-n8n/)). **Agent-built triage bot.** A triage agent with handoffs to specialists, each with narrow tools ([playbook](/playbooks/first-ai-agent-openai-agents-sdk/)). Start in draft mode. **Ticket-to-article.** Weekly, export resolved tickets for a topic and ask an assistant to draft a help article; a support lead edits and publishes. **Contact-driver analysis.** Monthly, analyze ticket exports to find the top drivers and share them with product. ## Compliance cautions General information, not legal advice. **Privacy:** tickets contain personal data subject to laws such as GDPR and state privacy laws, and to your DPAs with customers. **Disclosure:** some jurisdictions require telling people when they're interacting with an automated system. **Accuracy:** an AI agent's promises (refunds, SLAs) can bind your company; restrict what it can commit to. **Accessibility:** voice and chat agents should offer a path to a human. ## What a day looks like with AI Monday's queue opens with 300 tickets. AI triage has already labeled them by intent and urgency, routing billing issues to finance-trained agents and outage reports to tier two. For the two narrow intents in the pilot (password resets and invoice copies), AI-drafted replies wait for one-click approval. The support lead reviews the agent's traces from last week, fixes one wrong answer by updating a help article, and adds that ticket to the evaluation set. ## Your first 30 days - **Week 1:** Export last month's tickets and identify the top ten contact drivers with an assistant. - **Week 2:** Turn the top drivers into help articles drafted by AI and edited by your best agent. - **Week 3:** Deploy AI triage and routing in draft mode and measure accuracy on real tickets. - **Week 4:** Pilot AI-drafted replies for two narrow intents, with traces and an evaluation set, before any direct answering. Keep a simple log of time spent before and after each change. It's the only honest way to know whether a tool is earning its subscription, and it gives you real numbers rather than vendor claims. ## Questions to ask before buying - Can the AI be restricted to our knowledge base and specific actions? - What evaluation and tracing tools exist? - How is customer data retained and is it used for training? - How does escalation to a human work? If a vendor can't answer these clearly in writing, keep looking. Most tools on this page offer free tiers or trials, so you can test with non-sensitive sample data before committing. ## Common mistakes to avoid - Launching a customer-facing bot before testing it on a set of real tickets. - Letting the agent promise refunds, credits or SLAs it isn't authorized to give. - No easy path to a human, which frustrates customers and may breach rules in some places. - Never updating the knowledge base the AI relies on. The pattern behind all of these is the same: AI is a fast first draft and a tireless assistant, but the professional judgment, the accountability and the final review stay with people. --- ## AI tools for e-commerce and retail businesses URL: https://builderbriefai.com/industries/ecommerce-retail/ Summary: AI for online stores and retailers: product descriptions, product imagery, customer-service drafts, review analysis, video ads and automation, with advertising and privacy cautions. ## Top pain points 1. **Catalog content at scale.** Hundreds of products need descriptions, titles and metadata. 2. **Creative fatigue.** Ads need fresh images and videos constantly. 3. **Support volume.** "Where is my order?" and returns questions spike around promotions. 4. **Review insight.** Customers tell you what's wrong, but nobody reads all the reviews. 5. **Operations surprises.** Stockouts and order exceptions are noticed too late. ## Workflows that work **Batch product descriptions.** Export product specs to a spreadsheet, prompt an assistant with your brand voice and two great examples, and generate drafts row by row. A person checks every claim (materials, dimensions, care instructions) before publishing. **Review mining.** Export a few hundred reviews and ask for the top recurring complaints and praises with example quotes. Feed findings into product pages and product development. **Creative pipeline.** Concept images in Midjourney, layouts in Canva, short demo videos edited in Descript, and localized spokesperson videos in HeyGen. **Support drafts.** A Zapier agent or Make scenario drafts replies to common questions using your policy text; staff approve and send. ## Compliance cautions General information, not legal advice. **Truth in advertising:** claims about products (health, environmental, performance) must be substantiated; AI can invent benefits. **Endorsements and reviews:** don't generate fake reviews or testimonials; regulators treat that as deceptive. **Privacy:** customer personal data is subject to privacy laws such as state privacy statutes or GDPR. **Image rights:** check each AI tool's terms for commercial use and avoid generating trademarks or likenesses you don't have rights to. ## Your first 30 days - **Week 1:** Generate descriptions for your 20 weakest product pages and have someone verify every claim before publishing. - **Week 2:** Export recent reviews and run a theme analysis; turn the top three complaints into product page fixes or FAQ entries. - **Week 3:** Build one automation: low-stock or order-exception alerts to the right person. - **Week 4:** Introduce AI-drafted support replies with human approval and measure response time and customer satisfaction. Keep a simple log of time spent before and after each change. It's the only honest way to know whether a tool is earning its subscription, and it gives you real numbers rather than vendor claims. ## Questions to ask before buying - Can we use generated images and text commercially? - Is customer data used to train models? - Does it integrate with our store platform and helpdesk? - What happens to quality at peak season volume? If a vendor can't answer these clearly in writing, keep looking. Most tools on this page offer free tiers or trials, so you can test with non-sensitive sample data before committing. ## Common mistakes to avoid - Publishing AI descriptions with invented materials, sizes or benefits. - Using generated images that make products look different from what ships. - Automating refund replies without human approval. - Generating fake reviews or testimonials, which regulators treat as deceptive. The pattern behind all of these is the same: AI is a fast first draft and a tireless assistant, but the professional judgment, the accountability and the final review stay with people. --- ## AI tools for teachers, trainers and schools URL: https://builderbriefai.com/industries/education/ Summary: Practical AI for educators and training teams: lesson and quiz drafting, source-grounded study tools, accessible materials and admin automation, with student-privacy and academic-integrity cautions. ## Top pain points 1. **Preparation time.** Lesson plans, materials and assessments take evenings and weekends. 2. **Differentiation.** Students need the same content at different levels. 3. **Feedback load.** Detailed feedback on every assignment is hard at scale. 4. **Keeping up with research.** Evidence on what works is scattered. 5. **Admin overhead.** Emails, forms and scheduling. ## Workflows that work **Source-grounded study guides.** Upload readings into NotebookLM and generate a study guide, glossary and practice questions that cite the sources. Review before sharing. **Differentiated materials.** Ask an assistant to rewrite a passage at three reading levels while keeping key vocabulary, then check accuracy. **Rubric-guided feedback.** Provide your rubric and an anonymized sample; ask for feedback suggestions mapped to rubric criteria. The teacher decides the grade and final comments. **Evidence check.** Before adopting a new practice, ask Consensus or Elicit what studies say, then read the key papers. ## Compliance cautions General information, not legal advice. **Student privacy:** FERPA, COPPA (for children under 13 in the US) and state laws restrict sharing student data; use only approved tools. **Age limits:** many AI services set minimum ages in their terms. **Academic integrity:** publish clear rules; avoid relying on AI detectors as sole evidence. **Accuracy and bias:** review all AI-generated material before students see it. **Accessibility:** materials should meet your institution's accessibility standards. ## What a day looks like with AI A teacher uploads a unit's readings into NotebookLM on Sunday and generates a glossary and practice questions with citations, checking each against the text. On Monday, an assistant produces two simplified versions of the main reading for students who need them, which the teacher reviews. Rubric-based feedback suggestions on anonymized drafts speed up comments later in the week, while grades and final comments remain the teacher's own. ## Your first 30 days - **Week 1:** Use NotebookLM to build a study guide from one unit's readings and review it for accuracy. - **Week 2:** Create differentiated versions of one lesson and get feedback from colleagues. - **Week 3:** Draft a classroom or team AI-use policy aligned with your institution's guidance. - **Week 4:** Share what worked in a department meeting and agree on approved tools. Keep a simple log of time spent before and after each change. It's the only honest way to know whether a tool is earning its subscription, and it gives you real numbers rather than vendor claims. ## Questions to ask before buying - Has our institution approved this tool, and is there a student-data privacy agreement? - What are the minimum age requirements? - Can students' work be excluded from model training? - Are outputs accessible and exportable? If a vendor can't answer these clearly in writing, keep looking. Most tools on this page offer free tiers or trials, so you can test with non-sensitive sample data before committing. ## Common mistakes to avoid - Sharing AI-made materials with students without checking accuracy. - Entering identifiable student information into unapproved tools. - Relying on AI detectors as the only evidence of misconduct. - Rolling out tools without telling students and families what's allowed. The pattern behind all of these is the same: AI is a fast first draft and a tireless assistant, but the professional judgment, the accountability and the final review stay with people. --- ## AI tools for healthcare practices and clinics URL: https://builderbriefai.com/industries/healthcare-clinics/ Summary: Where AI helps clinics without touching clinical judgment: patient communications, front-desk automation, training content and admin, with careful HIPAA cautions. ## Top pain points 1. **Front-desk overload.** Phones, scheduling questions and forms eat staff time. 2. **Patient education.** Clear, readable handouts and FAQs take time to write and keep current. 3. **Staff training and turnover.** Onboarding new staff on procedures is repetitive. 4. **Administrative reporting.** Data moves between scheduling, billing and spreadsheets by hand. 5. **Marketing consistency.** Small practices struggle to keep websites and social channels current. ## Workflows that work **Patient-education drafts.** Give an assistant your approved clinical content and ask for a sixth-to-eighth-grade reading-level handout, with a clinician reviewing the final version. Keep a library so each topic is only written once. **Policy-to-checklist.** Paste a lengthy policy (no patient data) and ask for a one-page checklist for front-desk staff. Upload the full manuals into NotebookLM so new hires can ask "how do we handle a late cancellation?" and get an answer with the cited passage. **Training video.** Script onboarding modules with an assistant and produce them with Synthesia so every new hire gets the same accurate walkthrough. **Admin automation without PHI.** Job applications, supply requests, internal incident reports and marketing leads can flow through Make or Zapier into the right inbox or sheet. ## Compliance cautions This is general information, not legal or compliance advice. **HIPAA:** protected health information may only be shared with vendors under appropriate safeguards, typically including a Business Associate Agreement; many general AI plans are not covered. Assume nothing is HIPAA-eligible until your compliance officer confirms the specific plan and configuration. **Clinical judgment:** AI output must not replace clinician decision-making. **State privacy laws and professional board rules** may add requirements. **Accuracy:** every patient-facing statement should be clinician-reviewed. ## Your first 30 days - **Week 1:** Inventory tasks that involve no patient data (handouts, training, marketing, policies) and choose two to try. - **Week 2:** Draft five patient-education handouts from approved content with an assistant; route each to a clinician for review and sign-off. - **Week 3:** Upload the policy manual into a source-grounded tool for staff Q&A, and measure how many front-desk questions it answers correctly. - **Week 4:** Meet with your compliance officer to decide whether any PHI-related use is worth pursuing with a vendor that signs a BAA. Keep a simple log of time spent before and after each change. It's the only honest way to know whether a tool is earning its subscription, and it gives you real numbers rather than vendor claims. ## Questions to ask before buying - Will you sign a Business Associate Agreement for this plan? - Is any data used to train models, and can that be disabled contractually? - What audit logs and access controls are available? - How do you handle breach notification? If a vendor can't answer these clearly in writing, keep looking. Most tools on this page offer free tiers or trials, so you can test with non-sensitive sample data before committing. ## Common mistakes to avoid - Pasting patient details into a general chatbot to save a minute. - Publishing AI patient materials without clinician review. - Assuming a vendor is HIPAA-ready because its website says so; check the agreement. The pattern behind all of these is the same: AI is a fast first draft and a tireless assistant, but the professional judgment, the accountability and the final review stay with people. --- ## AI tools for insurance agencies and brokers URL: https://builderbriefai.com/industries/insurance/ Summary: AI for independent agencies and brokers: policy comparison summaries, client communications, renewal follow-up, meeting notes and marketing, with licensing, privacy and accuracy cautions. ## Top pain points 1. **Comparing policies.** Coverage differences are buried in long documents. 2. **Renewal churn.** Clients leave when they don't hear from you before renewal. 3. **Explaining coverage simply.** Jargon confuses clients. 4. **Data entry.** Information moves between quoting tools, the agency system and email. 5. **Marketing consistency.** Educational content is hard to produce regularly. ## Workflows that work **Coverage comparison draft.** Upload two policies (with permission and in an approved tool) and ask for a table of limits, deductibles, exclusions and endorsements with page references. The licensed agent verifies every cell before discussing it. **Renewal engine.** A Make scenario pulls upcoming renewals from your system or sheet, creates tasks, and drafts check-in emails for the agent to personalize. **Review meetings.** With consent, a notetaker records annual reviews; action items become tasks. **Education content.** Assistants draft seasonal content ("what to check before hurricane season"); a licensed person reviews claims. ## Compliance cautions General information, not legal advice. **Licensing:** advice about coverage must come from licensed professionals. **Privacy:** insurance data may be covered by laws such as GLBA in the US and state privacy laws; health information may raise additional obligations. **Advertising rules:** state insurance regulations govern marketing claims. **AI governance:** regulators have issued guidance on AI and unfair discrimination, particularly in underwriting and claims. ## What a day looks like with AI Each Monday, the renewal automation lists policies renewing in the next 60 days, creates tasks and drafts personal check-in emails. The agent edits and sends them in 20 minutes. For a client comparing two quotes, an approved tool produces a draft comparison table with page references; the licensed agent verifies every line before the review meeting, which is recorded with consent so action items land in the CRM. ## Your first 30 days - **Week 1:** Use an assistant for marketing and plain-language education drafts with licensed review. - **Week 2:** Build a renewal reminder automation for the next 90 days of renewals. - **Week 3:** Pilot coverage comparison tables in an approved tool on sample policies, verified line by line. - **Week 4:** Document review steps and compliance sign-off for AI-assisted client materials. Keep a simple log of time spent before and after each change. It's the only honest way to know whether a tool is earning its subscription, and it gives you real numbers rather than vendor claims. ## Questions to ask before buying - Does the vendor meet our privacy obligations for nonpublic personal information? - Is data used to train models? - Can it integrate with our agency management system? - What audit trail exists for AI-assisted outputs? If a vendor can't answer these clearly in writing, keep looking. Most tools on this page offer free tiers or trials, so you can test with non-sensitive sample data before committing. ## Common mistakes to avoid - Letting AI-drafted explanations go to clients without licensed review. - Uploading policyholder data to consumer AI accounts. - Marketing copy with coverage claims that don't match policy language. - Automating renewals with no human check on exceptions. The pattern behind all of these is the same: AI is a fast first draft and a tireless assistant, but the professional judgment, the accountability and the final review stay with people. --- ## AI tools for law firms and legal teams URL: https://builderbriefai.com/industries/legal/ Summary: Practical AI for law firms and in-house legal: document review prep, drafting first passes, meeting notes, intake and knowledge search, with confidentiality and professional-responsibility cautions. ## Top pain points 1. **Reading volume.** Contracts, discovery and regulations take hours of careful reading before analysis begins. 2. **First drafts.** Routine letters, summaries and memos consume associate time that clients increasingly push back on. 3. **Knowledge scattered across systems.** Prior work product exists but is hard to find. 4. **Intake friction.** Prospective clients wait for callbacks and drop off. 5. **Billable-time pressure.** Admin and non-billable tasks crowd out legal work. ## Workflows that work **Contract first-pass review.** Upload an agreement to a business-tier assistant and ask for a table of parties, term, renewal, termination rights, indemnities and limitation of liability, with section numbers. The attorney uses the table as a map, then reads the source. The value is orientation, not judgment. **Plain-language client updates.** After an attorney writes the substance, an assistant can turn it into a clear client email at the right reading level. The attorney approves the final text. **Document Q&A on a closed set.** Tools that answer only from uploaded sources with citations, such as NotebookLM, are better suited to "what does this policy say about X" than open-ended chat, because each answer points back to a passage. **Intake.** An agent-style assistant can collect basic facts, check conflicts against a list you maintain, and book consultations. It should never give legal advice or create the impression of representation. ## Compliance cautions This page is general information, not legal or ethics advice. Professional-responsibility guidance on AI is evolving and varies by jurisdiction; common themes include **competence** (understanding the tool's limits), **confidentiality** (client information and privilege), **supervision** of AI-assisted work, **candor to the tribunal** (verify every citation), and **communication with clients** about AI use where appropriate. Review each vendor's data handling, avoid consumer accounts for client matters, and check court-specific rules, some of which require disclosure of AI-assisted filings. ## Your first 30 days - **Week 1:** Pick one internal, non-privileged task (marketing content or policy rewriting) and use a business-tier assistant for it daily; note time saved. - **Week 2:** Write a one-page firm AI policy covering approved tools, prohibited data, citation verification and supervision; have partners sign off. - **Week 3:** Pilot contract first-pass tables on a public or sample agreement, and compare against an associate's manual review to calibrate trust. - **Week 4:** Add an intake assistant or document Q&A on approved materials, review results with the managing partner, and decide what to scale. Keep a simple log of time spent before and after each change. It's the only honest way to know whether a tool is earning its subscription, and it gives you real numbers rather than vendor claims. ## Questions to ask before buying - Will you sign terms that prohibit training on our data, and how long do you retain inputs? - Where is data stored and who at the vendor can access it? - Can we export or delete all matter data on request? - Does the tool cite sources so attorneys can verify every statement? If a vendor can't answer these clearly in writing, keep looking. Most tools on this page offer free tiers or trials, so you can test with non-sensitive sample data before committing. ## Common mistakes to avoid - Filing anything with a citation no one has checked. The pattern behind all of these is the same: AI is a fast first draft and a tireless assistant, but the professional judgment, the accountability and the final review stay with people. --- ## AI tools for marketing agencies URL: https://builderbriefai.com/industries/marketing-agencies/ Summary: How agencies use AI across research, content, creative, video, reporting and client ops, with starter stacks and client-confidentiality and disclosure cautions. ## Top pain points 1. **Content volume per client.** Retainers demand more output every quarter. 2. **Voice consistency.** Each client has a different voice, and freelancers rotate. 3. **Pitch speed.** Research and decks for new business take days. 4. **Reporting.** Monthly reports eat senior time. 5. **Margin pressure.** Clients expect AI efficiencies to show up in pricing. ## Workflows that work **Client voice projects.** Create one AI project per client containing the brand guide, approved examples and banned phrases. Every writer drafts inside it, so output is consistent regardless of who's on the account. **Pitch sprint.** Perplexity for cited market research, an assistant to synthesize positioning options, Gamma to turn the outline into a deck, Midjourney for concept visuals. **Content multiplication.** One long-form piece becomes a video (see our [blog-to-video playbook](/playbooks/blog-post-to-video-heygen-descript/)), social posts and an email. **Call notes to tasks.** Fathom summaries feed the project-management tool, so action items never depend on someone's memory. ## Compliance cautions General information, not legal advice. **Client confidentiality:** agreements often restrict sharing client data; check before using any AI tool. **Disclosure:** some platforms require labeling synthetic or AI-altered media, and endorsement rules require clear disclosure of paid relationships. **Likeness and voice:** only create avatars or voice clones with written consent. **Intellectual property:** check tools' commercial-use terms and avoid prompting with third-party trademarks or copyrighted characters. ## What a day looks like with AI An account manager starts the day with yesterday's client call summary already in the project tool. A writer drafts three blog outlines inside the client's AI project, which holds the brand guide and approved examples, then writes and edits. The designer generates moodboard concepts, finalizes in Canva, and the video editor cuts a client webinar into six captioned clips in Descript. Before delivery, a senior strategist reviews everything for accuracy and voice. ## Your first 30 days - **Week 1:** Set up one AI project per top client with brand guidelines and approved examples. - **Week 2:** Run a pitch sprint with AI research and deck tools and compare hours against your last pitch. - **Week 3:** Add a notetaker for client calls (with consent) and pipe action items into project management. - **Week 4:** Update contracts and SOWs with AI disclosure and ownership language reviewed by counsel. Keep a simple log of time spent before and after each change. It's the only honest way to know whether a tool is earning its subscription, and it gives you real numbers rather than vendor claims. ## Questions to ask before buying - Do client inputs stay private and out of training data? - What are the commercial-use and ownership terms for outputs? - Can we manage separate brand voices and permissions per client? - Are there admin controls and audit logs for the team? If a vendor can't answer these clearly in writing, keep looking. Most tools on this page offer free tiers or trials, so you can test with non-sensitive sample data before committing. ## Common mistakes to avoid - Mixing clients' materials in one AI workspace. - Delivering AI-generated assets without checking commercial-use terms. - Cloning voices or faces without written consent. - Passing AI efficiency savings on without updating scopes and pricing deliberately. The pattern behind all of these is the same: AI is a fast first draft and a tireless assistant, but the professional judgment, the accountability and the final review stay with people. --- ## AI tools for real estate agents and teams URL: https://builderbriefai.com/industries/real-estate/ Summary: Where AI saves real estate agents time: lead response, CRM notes, listing copy, virtual staging, video and research. Mapped tools, starter stacks and fair-housing cautions. **This is our hub for real estate.** Start with these in-depth guides: - [The AI tool stack for real estate agents in 2026](/blog/ai-tool-stack-for-real-estate-agents-2026/) - [Writing listing descriptions and social posts with ChatGPT and Claude (with fair-housing cautions)](/blog/listing-descriptions-and-social-posts-with-chatgpt-and-claude/) - [Automating lead follow-up and CRM notes](/blog/automate-real-estate-lead-follow-up-and-crm-notes/) - [Listing videos and virtual staging with AI](/blog/listing-videos-and-virtual-staging-with-ai/) - [An AI daily routine for a busy agent](/blog/ai-daily-routine-for-real-estate-agents/) ## Top pain points 1. **Speed to lead.** Inquiries arrive nights and weekends, and the first agent to respond thoughtfully often wins the conversation. 2. **Follow-up decay.** Long-horizon buyers and sellers need months of consistent, personal contact that's hard to sustain by hand. 3. **CRM hygiene.** Notes from calls, showings and consultations rarely make it into the CRM, so context is lost. 4. **Marketing volume.** Every listing needs descriptions, social posts, graphics, video and often staging, fast. 5. **Document overload.** HOA packets, disclosures, inspection reports and contracts are long, and deadlines are unforgiving. ## How the workflows fit together The pattern that works for most agents is **capture → organize → act**. Capture leads and conversations automatically (web forms, portals and an AI notetaker). Organize them in one CRM, with AI summaries attached to each contact. Act with AI-drafted, human-reviewed messages: an instant acknowledgment, a personal follow-up referencing what the client said, and a nurture check-in months later. Marketing follows a parallel pattern: one accurate fact sheet per listing feeds every asset, from the MLS description and social captions to the video script. Staging and video tools turn photos into richer media, and an editor like Descript turns one video into a week of clips. ## Compliance cautions This is general information, not legal advice. **Fair housing:** advertising must not indicate a preference or limitation based on protected classes under federal, state and local law; AI drafts need human review for people-describing language. **Advertising and MLS rules:** brokerage identification, disclosure of altered or virtually staged images, and restrictions on altering permanent features vary by state and MLS. **Recording consent:** state laws differ. **Client confidentiality and privacy:** keep client financial and personal data in brokerage-approved systems, and review AI vendors' data-use terms. **Texting and calling leads** is regulated in the US (for example under the TCPA); follow your brokerage's compliance process. ## Your first 30 days - **Week 1:** Build a listing fact-sheet template and use an AI assistant for your next description and social posts, with the fair-housing review checklist. - **Week 2:** Clean up your CRM, then add an instant, personal acknowledgment for new leads. - **Week 3:** Start using a notetaker for consultations, with consent, and push summaries into the CRM. - **Week 4:** Test virtual staging on one vacant listing (labeled per MLS rules) and cut one listing video into vertical clips. Keep a log of time spent before and after each change, so you know which tools actually earn their subscription. --- ## AI tools for recruiting and HR teams URL: https://builderbriefai.com/industries/recruiting-hr/ Summary: AI for job descriptions, sourcing research, interview notes, onboarding and HR knowledge, with careful cautions on hiring bias, automated decision laws and employee privacy. ## Top pain points 1. **Writing volume.** Job descriptions, outreach, offer letters and policies. 2. **Interview logistics.** Scheduling across interviewers and time zones. 3. **Note quality.** Inconsistent interview notes weaken hiring decisions. 4. **Repetitive employee questions.** "How many PTO days do I have?" answered by hand. 5. **Onboarding consistency.** Every manager onboards differently. ## Workflows that work **Structured interviews.** Use an assistant to turn the role's competencies into a structured question bank and scorecard. Interviewers use the same questions; a notetaker (with consent) captures answers; humans score. **Handbook assistant.** Upload the handbook and policies to NotebookLM so employees and managers get answers with citations to the exact policy text. Update sources when policies change. **Onboarding videos.** Script with an assistant, produce with Synthesia, and keep the modules current by editing the script rather than re-filming. **Sourcing research.** Clay can research target companies and public role information to focus outreach; personalize carefully and respect opt-outs. ## Compliance cautions General information, not legal advice. **Anti-discrimination law** applies to AI-assisted hiring just as to human hiring; AI can encode bias. **Automated decision rules:** some jurisdictions (for example, New York City's law on automated employment decision tools, and the EU AI Act's treatment of employment uses) impose audits, notices or other obligations. **Privacy:** candidate and employee data is protected by privacy laws; minimize what you share with vendors. **Recording consent** varies by location. ## What a day looks like with AI A recruiter drafts a job description with an assistant, removes two unnecessary requirements, and adds the company's required statements. Interviewers use the same structured question guide, and with candidates' consent a notetaker captures answers so interviewers can listen. Employees ask the handbook assistant how parental leave works and get the answer with a link to the exact policy section. Hiring decisions are made by people, using the scorecards. ## Your first 30 days - **Week 1:** Use an assistant to draft or refresh three job descriptions and a structured interview guide. - **Week 2:** Publish a source-grounded handbook assistant and collect employee feedback on answer quality. - **Week 3:** Pilot interview notes with candidate consent on one role, and compare interviewer satisfaction. - **Week 4:** Review any screening or ranking tools with employment counsel before considering them. Keep a simple log of time spent before and after each change. It's the only honest way to know whether a tool is earning its subscription, and it gives you real numbers rather than vendor claims. ## Questions to ask before buying - Is the tool used to make or substantially assist employment decisions, and has it been bias-audited? - What notices to candidates does it require in our jurisdictions? - How is candidate data stored, retained and deleted? - Can humans review and override every recommendation? If a vendor can't answer these clearly in writing, keep looking. Most tools on this page offer free tiers or trials, so you can test with non-sensitive sample data before committing. ## Common mistakes to avoid - Letting a tool reject candidates automatically. - Recording interviews without clear consent. - Copying AI job descriptions that include requirements the role doesn't need. - Putting sensitive employee data into tools HR hasn't approved. The pattern behind all of these is the same: AI is a fast first draft and a tireless assistant, but the professional judgment, the accountability and the final review stay with people. # Blog ## An AI daily routine for a busy real estate agent URL: https://builderbriefai.com/blog/ai-daily-routine-for-real-estate-agents/ Summary: A realistic hour-by-hour routine showing where AI assistants, CRMs, notetakers and automations fit into an agent's day, with prompts you can copy and guardrails to keep you compliant. AI doesn't make you a better agent by itself. It gives you back the time you lose to typing, sorting and remembering, so you can spend more of the day with people. Below is a realistic routine built around the tools in our [real estate AI stack](/blog/ai-tool-stack-for-real-estate-agents-2026/). Adapt the times to your market; the point is to give each AI task a home in your day so it becomes a habit. ## 7:00 AM: The 10-minute morning brief Before email pulls you in, get a plan. Paste into [ChatGPT](/tools/chatgpt/), [Claude](/tools/claude/) or [Gemini](/tools/gemini/) a quick dump of your calendar, today's CRM tasks and any notes: > Here are my appointments, CRM tasks and notes for today. Build a prioritized plan: (1) the three things that move a deal forward, (2) calls to make with a one-line purpose each, (3) what I can batch or delegate. Flag any conflicts. Keep it to one screen. If your brokerage uses Google Workspace with Gemini, you can do this inside Gmail and Calendar. Either way, avoid pasting sensitive client financial details into tools your brokerage hasn't approved. ## 7:30 AM: Inbox triage Two approaches: - **Manual with AI help:** ask your assistant to summarize long threads ("What does the buyer's agent need from me, and by when?") and draft replies you edit. - **Automated:** an automation that labels incoming email by type (new lead, active client, transaction, vendor, newsletter) and drafts replies to routine requests. Our [n8n inbox triage playbook](/playbooks/automate-inbox-triage-with-n8n/) shows how; the same pattern works in [Zapier](/tools/zapier-agents/) or [Make](/tools/make/). Rule: AI drafts, you send. ## 8:00 AM: Lead follow-up block Open your CRM ([Follow Up Boss](/tools/follow-up-boss/), [Lofty](/tools/lofty/) or similar) and work today's follow-up list. AI helps in two ways: 1. **Instant response** to overnight leads already happened automatically if you built the automation in our [lead follow-up guide](/blog/automate-real-estate-lead-follow-up-and-crm-notes/). 2. **Personal follow-ups:** for each warm lead, paste the CRM notes and ask: > Using these notes only, draft a 3-sentence text to follow up. Reference one specific thing they told me. End with a simple question. Casual, no emojis. Edit, send, log. Fifteen personalized follow-ups in thirty minutes is realistic once the prompt is saved. ## 9:30 AM: Listing marketing block If you have a listing in prep or live: - Draft or refresh the description and social posts with the prompts in our [listing-copy guide](/blog/listing-descriptions-and-social-posts-with-chatgpt-and-claude/), including its fair-housing guardrails. - Turn copy into graphics with [Canva](/tools/canva/). - Cut a vertical clip from the listing video in [Descript](/tools/descript/). Batch a week of social content in one sitting rather than posting reactively every day. ## 11:00 AM–3:00 PM: Appointments (let the notetaker work) For consultations and listing appointments held over video or recorded with consent, an AI notetaker like [Fathom](/tools/fathom/) or [Fireflies](/tools/fireflies/) captures the conversation and produces a summary and action items. Practical habits: - **Disclose and get consent** at the start, every time; rules vary by state. - After each meeting, glance at the action items while they're fresh and correct anything wrong. - If you've automated notes into the CRM, check that the note landed on the right contact. For in-person showings, a 60-second voice memo in the car afterwards ("Buyers loved the casita, worried about the HOA fee, want to see the Coral Canyon listing Thursday") can be transcribed and turned into a CRM note and a task by your assistant. ## 3:30 PM: Research and prep Preparing for tomorrow's listing appointment or a buyer tour: - Use [Perplexity](/tools/perplexity/) for cited background on local developments, zoning news or new amenities. Verify with the primary source (city, county, HOA) before telling a client. - Use your MLS and your brokerage's CMA tools for pricing. General AI tools are not a substitute for comps. - For a stack of HOA documents or disclosures, [NotebookLM](/tools/notebooklm/) lets you upload sources and ask questions with citations back to the documents ("What do the CC&Rs say about short-term rentals?"). Point clients to the documents and their attorney for interpretation; don't give legal advice. ## 4:30 PM: Transaction check-in Ask your assistant to turn your transaction checklist and today's emails into a status table: > From this checklist and these emails, list each open transaction with: next deadline, who owes what, and anything at risk in the next 7 days. Deadlines are where deals fail. Double-check every date against the contract itself. ## 5:00 PM: Sphere and nurture (15 minutes) Review the AI-drafted nurture emails your weekly automation produced, personalize two or three, and send. Add one value piece to your queue: a short market update, a "just listed" story, or a local event roundup. ## 5:15 PM: The end-of-day reset > Here's what happened today: [notes]. Update my plan for tomorrow, list follow-ups I promised and to whom, and draft any CRM notes I haven't logged. Then close the laptop. The system remembers so you don't have to. ## Weekly additions - **Monday:** AI-assisted market update script from your MLS stats; record or produce with an avatar in HeyGen. - **Wednesday:** content batch for the week. - **Friday:** review automations: did any lead go unanswered? Did any note fail to log? Improve one prompt. ## Guardrails that keep this safe - **You review everything client-facing.** Your license is on every message. - **Client data stays in approved tools.** Follow brokerage policy and your obligations of confidentiality. - **Fair housing applies to every word,** including texts, social posts and video scripts. - **No AI pricing opinions to clients.** Pricing comes from your CMA and professional judgment. - **Recording requires consent.** ## A note for teams If you lead a team, standardize the prompts. Keep a shared document with the approved morning-brief, follow-up, listing-copy and end-of-day prompts, plus the fair-housing guardrail block. New agents get productive faster, and the brokerage gets consistent, reviewable language instead of everyone improvising. ## Start small Don't adopt the whole routine at once. Week 1: the morning brief and end-of-day reset. Week 2: the follow-up prompt. Week 3: the notetaker. Week 4: one automation. Within a month, AI is handling the busywork and you're spending more time where agents add value: with clients. More real estate resources live on our [real estate industry hub](/industries/real-estate/). --- ## The AI tool stack for real estate agents in 2026 URL: https://builderbriefai.com/blog/ai-tool-stack-for-real-estate-agents-2026/ Summary: A practical, layer-by-layer AI stack for real estate agents: assistant, CRM, meeting notes, automation, listing media and research, with what each tool actually does and how to start. Real estate is a relationship business that runs on paperwork, follow-up and marketing. That second half is exactly where AI tools now save real hours. The challenge isn't finding AI tools; it's choosing a small stack that fits together and that you'll actually use between showings. This guide organizes the options into layers, explains what each one is for, and suggests a sensible starting point. Every tool linked here has a page in our [tracker](/tools/) with pricing notes and official links. A note before we start: we don't quote productivity statistics here, because most of the numbers floating around are vendor marketing. The honest way to measure value is to time a task before and after for two weeks. ## Layer 1: A general AI assistant (your writing and thinking partner) Every agent should have one general-purpose assistant: [ChatGPT](/tools/chatgpt/), [Claude](/tools/claude/) or [Gemini](/tools/gemini/). This is where you draft listing descriptions, rewrite emails for tone, summarize an inspection report, prepare for a listing appointment or turn voice notes into a to-do list. How to choose: - **ChatGPT** has the broadest feature set (file analysis, image generation, voice) and a free tier. - **Claude** is especially good with long documents and careful, natural writing, which matters for client communication. - **Gemini** fits naturally if your brokerage runs on Google Workspace, since it works inside Gmail and Docs on eligible plans. Pick one and get good at it before adding another. Save your best prompts (we share several in [our listing-copy guide](/blog/listing-descriptions-and-social-posts-with-chatgpt-and-claude/)). **Privacy rule of thumb:** don't paste client personal information, financials or anything under a confidentiality obligation into a consumer AI account. Use business plans with appropriate data controls and follow your brokerage's policy. ## Layer 2: The CRM (where every relationship lives) AI is only as useful as the data it can work with, and for agents that data lives in the CRM. Two real-estate-specific options we track: - [Follow Up Boss](/tools/follow-up-boss/) positions itself as "the real estate team OS": it pulls leads from many sources into one place, automates follow-up and routes leads across a team. It has a free trial, published per-user pricing, and a documented API, which matters for the automations below. - [Lofty](/tools/lofty/) is an all-in-one platform combining CRM, IDX websites, lead generation and AI agents, aimed at agents, teams and brokerages. Pricing is by request. General-purpose CRMs such as HubSpot also work, especially for agents who run a broader business. The key question: can it receive notes and tasks automatically from other tools? If not, everything else in this stack becomes manual copy-paste. ## Layer 3: Meeting and call notes Buyer consultations, listing appointments and vendor calls generate commitments that get lost. AI notetakers such as [Fathom](/tools/fathom/) and [Fireflies](/tools/fireflies/) record, transcribe and summarize meetings, and produce action items. Two cautions specific to our industry. First, **recording consent**: laws differ by state, and some require every party's consent. Always disclose that you're recording and get agreement. Second, **sensitive conversations**: some calls involve negotiation strategy or a client's finances. Decide in advance which meetings you never record. We cover connecting notes to your CRM in [Automating lead follow-up and CRM notes](/blog/automate-real-estate-lead-follow-up-and-crm-notes/). ## Layer 4: Automation (the glue) Automation platforms like [Make](/tools/make/) and [Zapier](/tools/zapier-agents/) connect the tools above so that information moves without you. Typical real estate automations: - New web lead → create CRM contact → send an immediate, personalized acknowledgment → alert you by text. - Meeting summarized → attach note to the CRM contact → create a follow-up task. - Listing goes live → generate social post drafts → put them in a review sheet. Start with one automation that removes a task you do daily. Zapier is the gentlest learning curve; Make gives more control over branching and data. ## Layer 5: Listing media (photos, staging and video) This is where AI is most visible to clients. - **Virtual staging:** [Virtual Staging AI](/tools/virtual-staging-ai/) furnishes empty-room photos in seconds and advertises pricing from about $1 per image. [BoxBrownie](/tools/boxbrownie/) offers virtual staging, photo editing and floor plans produced by a team of digital editors, typically within 24 hours. MLS rules commonly require disclosing virtually staged photos; check your MLS and label them clearly. - **Video:** [HeyGen](/tools/heygen/) creates avatar-presented videos from a script (you can create an avatar of yourself with consent), and [Descript](/tools/descript/) edits video by editing the transcript, which makes captions and short clips easy. - **Graphics:** [Canva](/tools/canva/) remains the default for flyers, social graphics and presentations, with AI features built in. Our deep dive: [Listing videos and virtual staging with AI](/blog/listing-videos-and-virtual-staging-with-ai/). ## Layer 6: Research and market insight [Perplexity](/tools/perplexity/) is useful for quick, cited research: zoning questions, local development news, or background before a listing appointment. Always click through to the primary source (the city, county or MLS) before repeating anything to a client. At the brokerage and portal level, computer-vision providers such as [Restb.ai](/tools/restb-ai/) tag property photos and detect features and condition at scale. Individual agents usually won't buy it directly, but it's worth knowing that this is how many listing platforms auto-tag photos. ## Three starter stacks **Solo agent, minimal budget:** one AI assistant (free or entry plan), your existing CRM, Canva, and pay-per-image virtual staging only when a listing is vacant. Focus on prompts and templates. **Productive solo agent or small team:** paid AI assistant, Follow Up Boss or Lofty, an AI notetaker, Zapier or Make with two or three automations, and Descript for video. **Luxury or high-volume team:** everything above plus HeyGen for consistent branded video, professional virtual staging and photo editing, and a documented AI policy for the team covering client data, disclosure and review before anything is published. ## How to roll it out without chaos 1. **Week 1:** adopt one assistant and build five saved prompts for tasks you do weekly. 2. **Week 2:** clean your CRM; automations multiply bad data. 3. **Week 3:** add one automation (new-lead response is the usual winner). 4. **Week 4:** add notetaking for consultations, with consent. 5. **Ongoing:** review everything AI writes before it reaches a client. Your license, not the software, is on the line. ## Compliance reminders (not legal advice) - **Fair housing:** AI can produce language that describes people instead of property. Review every description and ad; see our [listing-copy guide](/blog/listing-descriptions-and-social-posts-with-chatgpt-and-claude/). - **Advertising rules:** your state commission and MLS set rules on disclosures, brokerage identification and altered images. - **Privacy and confidentiality:** treat client data as confidential and follow your brokerage's policies. - **Recording consent:** follow your state's rules and disclose recording. For a day-by-day view of how these tools fit together, read [An AI daily routine for a busy agent](/blog/ai-daily-routine-for-real-estate-agents/), and see our [real estate industry hub](/industries/real-estate/) for more. --- ## Automating real estate lead follow-up and CRM notes with AI URL: https://builderbriefai.com/blog/automate-real-estate-lead-follow-up-and-crm-notes/ Summary: Three automations every agent can build: instant lead response, meeting notes into Follow Up Boss or HubSpot, and AI-drafted nurture emails, using Fathom or Fireflies with Make or Zapier. Speed and consistency win leads. A buyer who fills out a form on Saturday night and hears nothing until Monday has probably already booked a showing with someone else. And the clients you met with last month only stay warm if your notes and next steps are actually in the CRM. This guide walks through three automations that solve both problems. You can build them in an afternoon with [Make](/tools/make/) or [Zapier](/tools/zapier-agents/), an AI notetaker such as [Fathom](/tools/fathom/) or [Fireflies](/tools/fireflies/), and a CRM like [Follow Up Boss](/tools/follow-up-boss/), [Lofty](/tools/lofty/) or HubSpot. We won't quote "X% of leads go cold" stats; you know your own response times. Measure them before and after. ## Before you automate: three rules 1. **Clean the CRM first.** Merge duplicates and standardize lead sources and stages. Automation spreads bad data faster. 2. **Draft, don't auto-send, anything substantive.** An instant acknowledgment can be automatic; anything that answers a question, mentions a price or gives advice should be reviewed by you. 3. **Respect consent and communication laws.** Recording consent varies by state; texting leads is regulated (for example under the TCPA in the US), and email needs an opt-out. Follow your brokerage's compliance guidance. This isn't legal advice. ## Automation 1: Instant, personal lead response **Goal:** every new lead gets a relevant reply within minutes and you get alerted, 24/7. **How it works:** 1. **Trigger:** a new lead arrives. Many portals and websites already send leads into Follow Up Boss or Lofty; if so, trigger on "new person/lead created" in your CRM through Zapier or Make. Otherwise trigger on the form submission itself. 2. **AI step:** pass the lead's inquiry (property address, message, source) to ChatGPT or Claude through the automation platform's AI module with a prompt like: > Write a short, friendly first reply (under 90 words) from [Your Name], a real estate agent with [Brokerage], to a lead who inquired about [property] via [source]. Acknowledge their specific question, offer two showing time options ("tomorrow afternoon or Thursday morning"), and ask one qualifying question about timing. Don't state any facts about the property beyond what's in the inquiry. No exclamation marks. 3. **Action:** send the email from your account (or create a draft if you prefer review), and log the message on the CRM contact. 4. **Alert:** text or push-notify yourself with the lead's name, source and question. Most CRMs also have built-in action plans or automations for drip messages. Use those for scheduled follow-ups and keep the AI step for the personalized first touch. **Test:** submit five fake leads with different questions (a specific listing, a general "what's my home worth", a rental inquiry) and read every output. ## Automation 2: Meeting notes into the CRM **Goal:** after every buyer consultation or listing appointment, a summary and action items land on the client's CRM record, with a follow-up task. **Option A, native integrations (fastest):** many notetakers offer direct CRM integrations or Zapier/Make connections. Check your notetaker's integration list for your CRM first. **Option B, custom flow (more control):** 1. **Trigger:** the notetaker signals that a meeting summary is ready. Fireflies, for example, offers Webhooks V2 with a `meeting.summarized` event that sends the meeting ID to a URL; Make's custom webhook module can receive it. 2. **Fetch:** use an HTTP step to pull the meeting's title, attendees, summary and action items from the notetaker's API. Our [Fireflies + Make + HubSpot playbook](/playbooks/meeting-notes-to-crm-fireflies-make-hubspot/) shows the exact GraphQL query. 3. **Match:** search the CRM for the attendee's email. 4. **Write:** create a note on the contact. Follow Up Boss documents a Notes endpoint in its API; HubSpot has note and task modules in Make and Zapier. 5. **Task:** create a follow-up task due in 1–2 days ("Send comps and two off-market options"). **Agent-specific filter:** only push meetings with an external attendee, and exclude meetings titled with keywords like "negotiation" or "legal" if your brokerage prefers those notes stay off shared systems. **Note template:** ``` Consultation: {title} ({date}) Summary: {overview} Next steps: {action_items} ``` ## Automation 3: AI-assisted nurture that still sounds like you **Goal:** long-term leads (6–18 months out) hear from you with something useful, not a generic newsletter. 1. **Trigger:** a scheduled run (weekly) that pulls CRM contacts in a "nurture" stage whose last contact was more than 30 days ago. 2. **AI step:** for each, draft a short check-in based on the CRM notes: > Using only these CRM notes, draft a 3–4 sentence check-in email from [Your Name]. Reference one specific detail they mentioned (e.g. wanting a casita or a shorter commute) and offer one useful thing: a relevant new listing link I will add, a market update, or a quick call. Don't invent listings or numbers. Return "SKIP" if the notes are too thin. 3. **Action:** save drafts to a review list (a Google Sheet, or email drafts). Spend 15 minutes on Friday approving and personalizing them. This keeps your sphere warm without sounding robotic, because each email references something the client actually told you. ## Choosing Make or Zapier - **Zapier** has the gentlest setup and a very large app directory; good if you want the simplest path. - **Make** has a visual builder with routers, iterators and HTTP modules; better for the custom notes flow above. Both have free tiers for testing; usage-based pricing grows with volume, so check each vendor's current pricing. ## Measuring success Track three numbers for a month before and after: 1. Median time from lead arrival to first reply. 2. Percentage of consultations with a CRM note within 24 hours. 3. Number of nurture contacts touched per month. If the first number drops but replies feel generic, improve the prompt with examples of your best real replies. ## Common mistakes - **Fully automated replies that answer property questions.** Wrong facts from a bot become your problem. - **Recording without consent.** Disclose and confirm at the start of every call. - **Duplicate contacts.** Always search by email before creating a contact. - **Sending client data to tools your brokerage hasn't approved.** Check first. Next: build your full [AI tool stack](/blog/ai-tool-stack-for-real-estate-agents-2026/), or see how these automations fit into [an AI daily routine](/blog/ai-daily-routine-for-real-estate-agents/). More resources on our [real estate hub](/industries/real-estate/). --- ## Writing listing descriptions and social posts with ChatGPT and Claude (with fair-housing cautions) URL: https://builderbriefai.com/blog/listing-descriptions-and-social-posts-with-chatgpt-and-claude/ Summary: Copy-ready prompts for MLS descriptions, luxury listing stories and social posts, plus a fair-housing review checklist so AI-written copy describes the property, not the people. Listing copy is the perfect AI task: it's repetitive, it follows patterns, and a good first draft saves real time. It's also one of the riskiest, because a generic model has no idea about fair-housing law, MLS character limits or your brokerage's advertising rules. This guide gives you prompts that work in [ChatGPT](/tools/chatgpt/) or [Claude](/tools/claude/), and a review process to use every time. **Important:** this is general information, not legal advice. Fair-housing rules come from federal law, state law and sometimes local ordinances. Your brokerage, your state commission and a qualified attorney are the authorities. ## Start with a fact sheet, not a prompt The biggest quality jump comes from giving the model accurate, specific facts. Before prompting, write a quick fact sheet: - Address area (city/neighborhood), property type, beds, baths, square footage, lot size, year built - Top five features in order of importance (e.g. "floor-to-ceiling windows facing the red cliffs", "detached casita with kitchenette", "three-car garage with EV charger") - Recent updates with years - Outdoor living details (pool, outdoor kitchen, covered patio, views) - HOA and community amenities, if relevant - Anything you must **not** say (unverified square footage, permits you can't confirm) AI fills gaps by inventing. A thorough fact sheet leaves nothing to invent. ## Prompt 1: The MLS description > You are an experienced real estate copywriter. Write an MLS public remarks description using only the facts below. Limits: under [your MLS character limit] characters, no ALL CAPS, no exclamation marks, no superlatives you can't support ("best", "perfect"). Describe the property and its features only. Don't describe who should live there or the kind of people in the neighborhood. Don't mention schools' quality, places of worship or neighbors. End with a one-sentence invitation to schedule a showing. > > Facts: [paste fact sheet] Then ask for **three variations** in different tones (warm, crisp, luxury) and pick the best parts. ## Prompt 2: The luxury property story Luxury buyers respond to a sense of place. For a longer website or brochure version: > Write a 250–350 word property story for a luxury listing website. Structure: an opening line about the setting and light; a walk-through from arrival to the main living area to the primary suite to outdoor spaces; a closing paragraph about the location's lifestyle amenities (trails, golf, dining) stated factually. Use sensory, specific language drawn from the facts. Avoid clichés like "nestled", "boasts" and "dream home". Use only these facts: [fact sheet]. Southern Utah example of a factual setting line: "Morning light moves across the red rock from the great room's west-facing windows." Note it describes the view and the light, not the buyer. ## Prompt 3: Social posts in batches > From the listing facts below, write: (a) 3 Instagram captions under 150 words with 5 relevant hashtags each; (b) 2 Facebook posts under 120 words; (c) 1 LinkedIn post for my professional network. Each should highlight a different feature. Include "[Brokerage name]" where my brokerage must be identified. No emojis in the LinkedIn post. Describe the property, never the ideal buyer. Pair the captions with graphics from [Canva](/tools/canva/), and keep a running doc of captions that performed well so you can paste them into future prompts as style examples. ## Prompt 4: Open house and just-sold posts > Write an open house announcement (date, time, address placeholders) and a just-sold post thanking everyone involved without naming the clients or sharing the price unless I add it. Keep both under 80 words. Never put client names, sale terms or personal details in a prompt or a post without written permission. ## The fair-housing problem with AI copy Under the federal Fair Housing Act, advertising may not indicate a preference, limitation or discrimination based on race, color, religion, sex, disability, familial status or national origin. Many states and cities add more protected classes, such as source of income, age, sexual orientation or gender identity. AI models learned from decades of real ads, including bad ones. Watch for phrases that describe **people** rather than **property**: - Family-status language: "perfect for a young family", "ideal for empty nesters", "great for singles", "adults only". - Ability-related language: "perfect for active buyers", "not suitable for wheelchairs". Describe accessible features factually instead ("single-level living", "zero-step entry", "36-inch doorways"). - Religion or ethnicity proxies: naming a place of worship as a selling point, "traditional neighborhood", references to "the right kind of community". - Exclusionary hints: "exclusive", "private community" used to suggest who belongs, rather than describing gated access factually. Property-focused rewrites: "perfect for a growing family" becomes "four bedrooms and a bonus room"; "walking distance to [church]" becomes "walkable to downtown shops and parks"; "great for retirees" becomes "single-level floor plan with low-maintenance landscaping". ## Add guardrails to the prompt itself Put this block at the end of every listing prompt: > Fair-housing guardrails: describe the property, features, location and amenities only. Do not describe or imply a preferred buyer, household type, age, religion, race, national origin, sex, disability, or familial status. Do not reference schools' quality, places of worship, or neighborhood demographics. After the copy, list any phrases you are unsure about. The final line is useful: models will often flag their own borderline phrases. ## The 5-minute review checklist Before anything is published: 1. **Accuracy:** every fact matches the fact sheet and the MLS data. 2. **People test:** does any phrase describe who should live there? Rewrite it to describe a feature. 3. **Claims:** no unverifiable superlatives; square footage and lot size match the source you're allowed to cite. 4. **Required disclosures:** brokerage identification and any MLS or state-required language. 5. **Images:** virtually staged or edited photos labeled per MLS rules. 6. **Tone:** read it aloud. Does it sound like you? A writing assistant like [Grammarly](/tools/grammarly/) can catch clarity issues, but it is not a fair-housing reviewer. That responsibility stays with you and your broker. ## Build a reusable system Create a saved project or custom instructions in ChatGPT or Claude containing: your brand voice description, three of your best past descriptions as examples, your MLS character limit, your brokerage identification line, and the fair-housing guardrails above. Every new listing then needs only the fact sheet. Keep a log of edits you make to AI drafts. After ten listings you'll see patterns ("it always over-uses 'stunning'") and can add those to your instructions. ## What AI should not do for you - Decide what to disclose about property condition. That's a legal and professional judgment. - Write anything about the neighborhood's people, safety or schools. - Send or post on your behalf without review. Used this way, AI turns a 45-minute writing task into a 10-minute editing task, while you remain the professional accountable for every word. Next: [listing videos and virtual staging](/blog/listing-videos-and-virtual-staging-with-ai/), or see the full [real estate AI stack](/blog/ai-tool-stack-for-real-estate-agents-2026/). --- ## Listing videos and virtual staging with AI: a practical guide for agents URL: https://builderbriefai.com/blog/listing-videos-and-virtual-staging-with-ai/ Summary: How agents use AI for listing media: virtual staging with Virtual Staging AI or BoxBrownie, avatar and narrated listing videos with HeyGen, editing and social clips in Descript, plus MLS disclosure cautions. Buyers meet your listing on a screen first. Vacant rooms look smaller and colder in photos, and video consistently gets more attention on social platforms than static images. AI tools now make both staging and video affordable for every listing, not just the luxury ones. This guide covers how to use them well, and where the rules require care. ## Part 1: Virtual staging ### What the tools do - [Virtual Staging AI](/tools/virtual-staging-ai/) is a self-serve web app: upload a photo of an empty room, choose a room type and style, and get a furnished version back in seconds. Its site advertises a free trial and pricing from about $1 per image. - [BoxBrownie](/tools/boxbrownie/) offers virtual staging alongside photo editing, item removal, floor plans and renders, produced by its team of digital editors with delivery typically within 24 hours, priced per image or service. The trade-off is speed and cost versus control: instant AI staging lets you try several styles in minutes; editor-produced staging gives you more say over furniture choices and fewer odd artifacts. ### Getting good results 1. **Start with great photography.** Staging can't fix a dark, crooked, low-resolution photo. Shoot level, well-lit, wide but not distorted. 2. **Stage the rooms that matter:** main living area, primary bedroom, and any room whose purpose is unclear (a loft or flex room). 3. **Match the style to the property and market.** For a contemporary home in Southern Utah's red-rock settings, warm modern or desert-modern styles usually suit the architecture better than traditional furniture. 4. **Check scale and realism.** Look for furniture blocking doors, rugs floating over stairs, or a bed too large for the room. Regenerate or request a revision. 5. **Keep the original.** Always publish the empty-room photo alongside or have it available. ### Disclosure and accuracy Virtually staged images must not misrepresent the property. Many MLSs require you to label virtually staged photos and prohibit altering permanent features (removing a power line, changing a view, covering damage). Rules vary by MLS and state, so check yours. A simple caption like "Virtually staged" on each staged image is a common practice. This is general guidance, not legal advice. ## Part 2: Listing videos ### Three formats that work 1. **Narrated walkthrough:** your photos or footage with a voiceover and captions. Simple and effective for every listing. 2. **Agent-presented video:** you, or an AI avatar of you, introducing the property and its location. 3. **Short social clips:** 15–45 second vertical videos highlighting one feature each. ### Writing the script with AI Use [ChatGPT](/tools/chatgpt/) or Claude with your listing fact sheet: > Write a 60–90 second video script for a listing tour. Structure: a hook about the setting, a room-by-room walkthrough in the order of the photos I list, and a closing line with my name and brokerage. Use only these facts. Describe the property, never the ideal buyer. Mark each line with the photo or clip it goes with. > > Facts: [fact sheet]. Shot list: [1. exterior at dusk, 2. great room, 3. kitchen...] The same fair-housing guardrails apply to scripts as to written ads. See our [listing-copy guide](/blog/listing-descriptions-and-social-posts-with-chatgpt-and-claude/). ### Presenting with HeyGen [HeyGen](/tools/heygen/) creates videos with AI avatars from a script. You can use a stock presenter or create an avatar of yourself (from video, or from a single front-facing photo, according to HeyGen's site) and clone your voice, with your consent. In HeyGen's AI Studio you can place your own footage or photos as the background and position the avatar in the scene, so your avatar can "stand in" front of the listing photos. When it works well: consistent weekly market updates, listing intros when you're short on time, and translated versions for international buyers (HeyGen offers video translation into many languages). Be thoughtful: clients hire you for trust. Many agents keep AI-avatar video for routine content and record themselves for flagship listings. Label AI-generated presenters where platform rules require it; it's also good practice. ### Editing in Descript [Descript](/tools/descript/) edits video by editing its transcript: delete a sentence from the text and it's removed from the video. For agents this makes it easy to: - Tighten a self-recorded walkthrough by removing "ums" with its filler-word removal. - Add captions, since most social video is watched without sound. - Cut a 2-minute tour into three vertical clips. - Improve audio recorded in an echoing empty house with its Studio Sound feature. For voice-only narration without recording yourself, a text-to-speech tool such as [ElevenLabs](/tools/elevenlabs/) can generate a voiceover, which you then edit in Descript. ## Part 3: A repeatable listing-media workflow 1. **Shoot day:** professional photos plus 5–10 short video clips (doorway reveals, view pans, outdoor living). 2. **Same day:** send vacant-room photos for virtual staging. 3. **Day 2:** write the script with AI from the fact sheet; review it for accuracy and fair-housing language. 4. **Day 2:** produce the narrated or avatar video; edit and caption in Descript; make three vertical clips. 5. **Day 3:** design graphics in [Canva](/tools/canva/), label staged photos, publish to MLS (per its media rules), website and social. ## Where portals and brokerages use AI Behind the scenes, computer-vision providers like [Restb.ai](/tools/restb-ai/) tag property photos and detect features and condition for listing platforms, MLSs and valuation tools. It's useful context: the accuracy of your photos and captions increasingly feeds automated systems, not just human eyes. ## Checklist before publishing - Staged images labeled per MLS rules; originals available. - No permanent features altered. - Script facts match the listing data. - No people-describing language in scripts, captions or hashtags. - Brokerage identification included where required. - AI presenter disclosed where required. - Client and occupant privacy respected: no personal photos, documents or identifiable items visible. ## How to judge whether it's working Compare listings with and without staging and video on the metrics you can actually see: portal views and saves, social reach and watch time, showing requests in the first two weeks, and seller feedback. Keep it simple, track it in a spreadsheet, and give each experiment a few listings before drawing conclusions. Next: the [complete AI tool stack for agents](/blog/ai-tool-stack-for-real-estate-agents-2026/), or the step-by-step [blog-to-video playbook](/playbooks/blog-post-to-video-heygen-descript/). # Newsletter issues ## Your first AI agent in 30 minutes (+ 5 tools worth your time) URL: https://builderbriefai.com/issues/issue-1/ Summary: Hands-on playbooks, honest picks, and one setting that silently deletes your emails. Hey there, Welcome to the first Builder Brief. Every week we test-read the docs so you don't have to, then send you one practical workflow, a handful of tools worth knowing, and one tip you can use today. It's for two kinds of people: those building AI agents, and those using AI to get real work done. Most weeks there's something for both. This week we launched **[Playbooks](/playbooks/)**: step-by-step tutorials with time, cost, prerequisites, pitfalls and an FAQ, each checked against the official docs. We also added **[AI tools by industry](/industries/)**, from real estate to legal to SaaS support. ## Featured playbook: Your first AI agent in 30 minutes **[Read the playbook →](/playbooks/first-ai-agent-openai-agents-sdk/)** Using the OpenAI Agents SDK, you'll build a support triage agent that: - **calls your code** through a tool (a Python function the model can choose to call), - **hands off** to Billing or Technical specialists, - and shows every step in the OpenAI dashboard's **Trace viewer**. The best tip in it: `result.last_agent.name` tells you which specialist answered. Write ten real customer messages with the expected specialist and you've got a regression test for every prompt change. Not a coder? Try **[Ship an internal tool with Lovable](/playbooks/ship-an-internal-tool-with-lovable/)** instead. ## 5 tools worth your time 1. **[Claude Code](/tools/claude-code/)**. An agent that works across your whole repo from the terminal, IDE or desktop. Why it matters: with MCP servers it can read your issue tracker or docs directly, so you stop pasting context. 2. **[n8n](/tools/n8n/)**. Self-hostable automation with real AI nodes. Why it matters: you can keep sensitive data (like email) on your own server and still use AI classification. See our [inbox triage playbook](/playbooks/automate-inbox-triage-with-n8n/). 3. **[Ollama](/tools/ollama/)**. Run open models locally with an OpenAI-compatible API. Why it matters: free, private inference for dev and sensitive preprocessing. [Playbook](/playbooks/run-local-models-with-ollama/). 4. **[NotebookLM](/tools/notebooklm/)**. Answers grounded in documents you upload, with citations. Why it matters: it's one of the simplest ways for non-technical teams to get trustworthy answers from their own policies and manuals. 5. **[Fireflies](/tools/fireflies/)**. AI meeting notes with an API and webhooks. Why it matters: Webhooks V2 + Make can push every call summary into your CRM automatically. [Playbook](/playbooks/meeting-notes-to-crm-fireflies-make-hubspot/). ## Comparison of the week: n8n vs Make Both connect your apps and add AI steps. **Make** is the friendlier visual builder with a large app library and a free tier for testing. **n8n** can be self-hosted, has deeper AI and code options, and suits technical ops teams. Rule of thumb: if no one on your team wants to maintain a server, start with Make; if data control or high volume matters, look at n8n. **[Full comparison →](/compare/n8n-vs-make/)** ## Quick tip: the n8n setting that deletes your email (sort of) In n8n's **Text Classifier** node, the "When No Clear Match" option defaults to **Discard Item**. Anything the AI can't classify silently drops out of your workflow. Switch it to **Output on Extra, 'Other' Branch** and send those items to a human-review label. Thirty seconds, and nothing gets lost. --- **Working in real estate?** We just published five practical guides, starting with [the AI tool stack for agents in 2026](/blog/ai-tool-stack-for-real-estate-agents-2026/). Reply and tell us which tool or workflow you want broken down next. We read every reply. # Best AI tools by job ## Best AI tools for sales URL: https://builderbriefai.com/best/ai-tools-for-sales/ Prospecting, enrichment, outreach and call notes: the AI tools sales teams actually use. 1. Clay: Data enrichment and AI research agents for go-to-market teams. Pricing: Free tier; paid plans. 2. Apollo.io: B2B sales platform with contact data and AI outreach. Pricing: Free tier; paid plans. 3. HubSpot Breeze: AI agents and assistant built into HubSpot CRM. Pricing: Included in HubSpot plans. 4. Fathom: AI notetaker for Zoom, Google Meet and Teams. Pricing: Free tier; paid plans. 5. Lindy: Build AI assistants that handle email, meetings and workflows. Pricing: Free tier; paid plans. 6. ChatGPT: General AI assistant with search, file analysis, projects and agent mode. Pricing: Free; paid Plus, Pro, Business, Enterprise. 7. Copy.ai: GTM AI platform for sales and marketing workflows. Pricing: Free tier; paid plans. 8. Perplexity: Answer engine that searches the web and cites sources. Pricing: Free; paid Pro and Enterprise. ## Best AI tools for marketing URL: https://builderbriefai.com/best/ai-tools-for-marketing/ Content, design, video and research tools for marketers. 1. Jasper: AI content platform for marketing teams. Pricing: Paid plans with free trial. 2. Canva: Design platform with Magic Studio AI features. Pricing: Free; paid Pro and Teams. 3. Gamma: Generate presentations, docs and websites with AI. Pricing: Free tier; paid plans. 4. HeyGen: AI avatar videos, translation and lip-sync. Pricing: Free tier; paid plans. 5. Descript: Edit video and podcasts by editing the transcript, with AI tools. Pricing: Free tier; paid plans. 6. Grammarly: AI writing assistance across apps. Pricing: Free; paid Pro plans. 7. Perplexity: Answer engine that searches the web and cites sources. Pricing: Free; paid Pro and Enterprise. 8. Midjourney: AI image (and video) generation from text prompts. Pricing: Paid subscription plans. 9. Claude: AI assistant for writing, analysis and research, with projects and connectors to work apps. Pricing: Free; paid Pro, Max, Team, Enterprise. ## Best AI tools for operations URL: https://builderbriefai.com/best/ai-tools-for-operations/ Automation and agent platforms that remove repetitive ops work. 1. Zapier Agents: No-code AI agents that act across thousands of connected apps. Pricing: Free tier; paid Zapier plans. 2. n8n: Workflow automation platform with AI agent nodes; self-host or cloud. Pricing: Free self-hosted; paid cloud plans. 3. Make: Visual automation platform for connecting apps, with AI agents. Pricing: Free tier; paid plans. 4. Relevance AI: No-code platform to build and run teams of AI agents. Pricing: Free tier; paid plans. 5. Lindy: Build AI assistants that handle email, meetings and workflows. Pricing: Free tier; paid plans. 6. Airtable: App platform with AI fields and agents. Pricing: Free; paid plans. 7. Notion AI: AI built into Notion for writing, search across connected apps and meeting notes. Pricing: Included in Notion Business and Enterprise plans. 8. Glean: Work AI platform that searches across company apps. Pricing: Enterprise pricing. ## Best AI tools for developers URL: https://builderbriefai.com/best/ai-tools-for-developers/ Coding agents, editors, frameworks and model APIs for software developers. 1. Claude Code: Agentic coding tool that runs in the terminal and IDEs, reads a codebase and makes multi-file edits. Pricing: Included with Claude Pro/Max plans or API usage. 2. Cursor: AI-first code editor with agent mode, tab completion and background agents. Pricing: Free Hobby plan; paid Pro and Business plans. 3. Codex: OpenAI's software engineering agent, available as a CLI, IDE extension and cloud agent inside ChatGPT. Pricing: Included with ChatGPT Plus/Pro/Business plans. 4. GitHub Copilot: AI pair programmer in editors and on GitHub, including a coding agent that works from issues. Pricing: Free tier; paid Pro, Business and Enterprise plans. 5. Windsurf: AI-native code editor with the Cascade agent for multi-file edits. Pricing: Free tier; paid Pro and Teams plans. 6. Cline: Open-source autonomous coding agent extension for VS Code. Pricing: Open source; bring your own API key. 7. LangGraph: Library for building stateful, long-running agents as graphs, with persistence and human-in-the-loop. Pricing: Open source; paid LangGraph Platform/LangSmith. 8. OpenRouter: One API for many LLM providers, with per-model pricing listed on the site. Pricing: Pay-as-you-go model credits. 9. LangSmith: Tracing, evaluation and monitoring platform for LLM apps and agents. Pricing: Free Developer tier; paid Plus and Enterprise. ## Best AI tools for meetings URL: https://builderbriefai.com/best/ai-tools-for-meetings/ AI notetakers that record, transcribe and summarize calls. 1. Granola: AI notepad that enhances your own meeting notes using the call transcript. Pricing: Free tier; paid plans. 2. Otter.ai: AI meeting notes, transcription and meeting agent. Pricing: Free tier; paid plans. 3. Fireflies.ai: AI notetaker that records, transcribes and summarizes meetings. Pricing: Free tier; paid plans. 4. Fathom: AI notetaker for Zoom, Google Meet and Teams. Pricing: Free tier; paid plans. ## Best AI tools for research URL: https://builderbriefai.com/best/ai-tools-for-research/ AI search and research assistants with sources. 1. Perplexity: Answer engine that searches the web and cites sources. Pricing: Free; paid Pro and Enterprise. 2. NotebookLM: Upload documents and get grounded summaries, Q&A and Audio Overviews. Pricing: Free; higher limits with Google AI plans. 3. Elicit: AI research assistant for searching and summarizing papers. Pricing: Free tier; paid plans. 4. Consensus: AI search engine over peer-reviewed research. Pricing: Free tier; paid plans. 5. Gemini: Google's AI assistant, also built into Gmail, Docs and other Workspace apps. Pricing: Free; paid Google AI plans. ## Best AI tools for building ai agents URL: https://builderbriefai.com/best/ai-tools-for-agent-builders/ Frameworks, protocols and observability for building agents. 1. OpenAI Agents SDK: Lightweight framework for building multi-agent workflows with tools, handoffs and tracing. Pricing: Open source (MIT); pay for model API usage. 2. LangGraph: Library for building stateful, long-running agents as graphs, with persistence and human-in-the-loop. Pricing: Open source; paid LangGraph Platform/LangSmith. 3. CrewAI: Python framework for orchestrating role-based teams of agents. Pricing: Open source framework; paid enterprise platform. 4. Pydantic AI: Python agent framework built by the Pydantic team with type-safe outputs. Pricing: Free, open source. 5. Mastra: TypeScript framework for building AI agents, workflows and RAG. Pricing: Open source; paid cloud. 6. AI SDK: TypeScript toolkit for building AI apps and agents across model providers. Pricing: Free, open source. 7. LlamaIndex: Framework for building agents and RAG apps over your data; LlamaCloud for parsing. Pricing: Open source; paid LlamaCloud. 8. AutoGen: Open-source framework from Microsoft for multi-agent applications. Pricing: Free, open source. 9. Model Context Protocol: Open protocol for connecting AI apps and agents to tools and data sources through MCP servers. Pricing: Open standard, free. 10. LangSmith: Tracing, evaluation and monitoring platform for LLM apps and agents. Pricing: Free Developer tier; paid Plus and Enterprise. # Comparisons ## Cursor vs Windsurf URL: https://builderbriefai.com/compare/cursor-vs-windsurf/ - Cursor (Anysphere, AI code editor): AI-first code editor with agent mode, tab completion and background agents. Pricing: Free Hobby plan; paid Pro and Business plans. - Windsurf (Cognition, AI code editor): AI-native code editor with the Cascade agent for multi-file edits. Pricing: Free tier; paid Pro and Teams plans. ## Claude Code vs Codex URL: https://builderbriefai.com/compare/claude-code-vs-openai-codex/ - Claude Code (Anthropic, Coding agent): Agentic coding tool that runs in the terminal and IDEs, reads a codebase and makes multi-file edits. Pricing: Included with Claude Pro/Max plans or API usage. - Codex (OpenAI, Coding agent): OpenAI's software engineering agent, available as a CLI, IDE extension and cloud agent inside ChatGPT. Pricing: Included with ChatGPT Plus/Pro/Business plans. ## ChatGPT vs Claude URL: https://builderbriefai.com/compare/chatgpt-vs-claude/ - ChatGPT (OpenAI, Assistant): General AI assistant with search, file analysis, projects and agent mode. Pricing: Free; paid Plus, Pro, Business, Enterprise. - Claude (Anthropic, Assistant): AI assistant for writing, analysis and research, with projects and connectors to work apps. Pricing: Free; paid Pro, Max, Team, Enterprise. ## n8n vs Make URL: https://builderbriefai.com/compare/n8n-vs-make/ - n8n (n8n, Automation): Workflow automation platform with AI agent nodes; self-host or cloud. Pricing: Free self-hosted; paid cloud plans. - Make (Make, Automation): Visual automation platform for connecting apps, with AI agents. Pricing: Free tier; paid plans. ## n8n vs Zapier Agents URL: https://builderbriefai.com/compare/n8n-vs-zapier-agents/ - n8n (n8n, Automation): Workflow automation platform with AI agent nodes; self-host or cloud. Pricing: Free self-hosted; paid cloud plans. - Zapier Agents (Zapier, Automation): No-code AI agents that act across thousands of connected apps. Pricing: Free tier; paid Zapier plans. ## LangGraph vs CrewAI URL: https://builderbriefai.com/compare/langgraph-vs-crewai/ - LangGraph (LangChain, Agent framework): Library for building stateful, long-running agents as graphs, with persistence and human-in-the-loop. Pricing: Open source; paid LangGraph Platform/LangSmith. - CrewAI (CrewAI, Agent framework): Python framework for orchestrating role-based teams of agents. Pricing: Open source framework; paid enterprise platform. ## Lovable vs Bolt.new URL: https://builderbriefai.com/compare/lovable-vs-bolt/ - Lovable (Lovable, App builder): Build full-stack web apps by chatting; popular with vibe coders. Pricing: Free tier; paid plans. - Bolt.new (StackBlitz, App builder): Prompt-to-full-stack-app builder that runs in the browser. Pricing: Free tier; paid token plans. ## Otter.ai vs Fireflies.ai URL: https://builderbriefai.com/compare/otter-vs-fireflies/ - Otter.ai (Otter.ai, Meeting notes): AI meeting notes, transcription and meeting agent. Pricing: Free tier; paid plans. - Fireflies.ai (Fireflies.ai, Meeting notes): AI notetaker that records, transcribes and summarizes meetings. Pricing: Free tier; paid plans. ## Perplexity vs ChatGPT URL: https://builderbriefai.com/compare/perplexity-vs-chatgpt/ - Perplexity (Perplexity AI, AI search): Answer engine that searches the web and cites sources. Pricing: Free; paid Pro and Enterprise. - ChatGPT (OpenAI, Assistant): General AI assistant with search, file analysis, projects and agent mode. Pricing: Free; paid Plus, Pro, Business, Enterprise. ## GitHub Copilot vs Cursor URL: https://builderbriefai.com/compare/github-copilot-vs-cursor/ - GitHub Copilot (GitHub, Coding assistant): AI pair programmer in editors and on GitHub, including a coding agent that works from issues. Pricing: Free tier; paid Pro, Business and Enterprise plans. - Cursor (Anysphere, AI code editor): AI-first code editor with agent mode, tab completion and background agents. Pricing: Free Hobby plan; paid Pro and Business plans. ## Midjourney vs Canva URL: https://builderbriefai.com/compare/midjourney-vs-canva/ - Midjourney (Midjourney, Image): AI image (and video) generation from text prompts. Pricing: Paid subscription plans. - Canva (Canva, Design): Design platform with Magic Studio AI features. Pricing: Free; paid Pro and Teams. ## HeyGen vs Synthesia URL: https://builderbriefai.com/compare/heygen-vs-synthesia/ - HeyGen (HeyGen, Video): AI avatar videos, translation and lip-sync. Pricing: Free tier; paid plans. - Synthesia (Synthesia, Video): AI video platform with avatars for training and business video. Pricing: Free tier; paid plans. # Tool directory (71 tools) ## Claude Code URL: https://builderbriefai.com/tools/claude-code/ Maker: Anthropic | Category: Coding agent | Audience: Builders Summary: Agentic coding tool that runs in the terminal and IDEs, reads a codebase and makes multi-file edits. Pricing: Included with Claude Pro/Max plans or API usage Official site: https://www.anthropic.com/claude-code Best for: Developers working in large existing codebases; Multi-file refactors and test-fixing loops; Teams that want an agent in the terminal, IDE and desktop Not for: People who never touch a terminal or code; Teams that cannot send code to a cloud model Pros: Works across many files and runs commands itself; Extensible with MCP servers, plugins and hooks; Available in terminal, IDEs and desktop Cons: Needs a paid Claude plan or API usage; Agentic runs can consume a lot of usage; You must review changes; it can be confidently wrong Use cases: Fix failing tests: "Run the test suite, find why the auth tests fail, fix the root cause and re-run until green. Explain the change."; Explain an unfamiliar repo: "Give me a map of this codebase: main modules, data flow, and where payments are handled."; Connect your tools via MCP: Add a server with claude mcp add --transport http notion https://mcp.notion.com/mcp, then: "Implement the spec in the Notion page Onboarding v2." ## Codex URL: https://builderbriefai.com/tools/openai-codex/ Maker: OpenAI | Category: Coding agent | Audience: Builders Summary: OpenAI's software engineering agent, available as a CLI, IDE extension and cloud agent inside ChatGPT. Pricing: Included with ChatGPT Plus/Pro/Business plans Official site: https://openai.com/codex/ Best for: ChatGPT subscribers who want a coding agent at no extra subscription; Delegating well-scoped tasks to a cloud agent; Terminal-first developers Not for: Non-developers; Codebases you are not allowed to share with OpenAI Pros: Included with paid ChatGPT plans; CLI, IDE extension and cloud agent share one account; Open-source CLI Cons: Usage limits depend on plan; Cloud tasks need your repo connected; Output still needs human review Use cases: Delegate a bug fix: "Find why the CSV export drops the last row, fix it and add a regression test."; Code review: Ask Codex to review a branch and list risky changes before you open a PR.; Scaffold a feature: "Add a /health endpoint that checks the database and returns JSON status." ## Cursor URL: https://builderbriefai.com/tools/cursor/ Maker: Anysphere | Category: AI code editor | Audience: Builders Summary: AI-first code editor with agent mode, tab completion and background agents. Pricing: Free Hobby plan; paid Pro and Business plans Official site: https://cursor.com Best for: Developers who want AI built into a VS Code-style editor; Fast inline edits and tab completion; Mixing chat, agent and manual coding Not for: People who prefer a terminal-only agent; Teams locked into another IDE such as JetBrains Pros: Familiar editor; imports VS Code settings and extensions; Strong tab completion; Supports MCP servers Cons: Heavy agent use needs a paid plan; Another editor to adopt for teams; Changes still need review Use cases: Agent edits: Prompt in Agent mode: "Add pagination to the users table, update the API and tests."; Codebase Q&A: "Where do we validate email addresses? Show all call sites."; Refactor with rules: Add a project rule describing your code style, then ask for a refactor that follows it. ## GitHub Copilot URL: https://builderbriefai.com/tools/github-copilot/ Maker: GitHub | Category: Coding assistant | Audience: Builders Summary: AI pair programmer in editors and on GitHub, including a coding agent that works from issues. Pricing: Free tier; paid Pro, Business and Enterprise plans Official site: https://github.com/features/copilot Best for: Teams already on GitHub; Completions inside many editors including JetBrains and VS Code; Assigning issues to a coding agent Not for: Teams not using GitHub; People who want a standalone app builder Pros: Free tier available; Deep GitHub integration; Works across popular editors Cons: Best features need paid plans; Agent quality depends on issue clarity; Org admins must enable some features Use cases: Issue to PR: Assign a well-written GitHub issue to Copilot coding agent and review the pull request it opens.; Inline completion: Write a function signature and docstring; accept the suggested body.; Explain code: Select a block and ask Copilot Chat: "Explain this and list edge cases." ## OpenAI Agents SDK URL: https://builderbriefai.com/tools/openai-agents-sdk/ Maker: OpenAI | Category: Agent framework | Audience: Builders Summary: Lightweight framework for building multi-agent workflows with tools, handoffs and tracing. Pricing: Open source (MIT); pay for model API usage Official site: https://openai.github.io/openai-agents-python/ Best for: Python or TypeScript developers building agents with tools and handoffs; Prototyping multi-agent workflows quickly; Teams that want built-in tracing Not for: No-code users; Teams wanting explicit graph-based state machines (see LangGraph) Pros: Small set of primitives; quick to learn; Tracing in the OpenAI dashboard; Open source Cons: API usage costs extra; Best experience with OpenAI models; Young, fast-changing API Use cases: Support triage: A triage agent hands off to Billing and Technical specialists.; Tool-using assistant: Wrap your API in a function tool so the agent can look up orders.; Guardrailed workflow: Add input/output guardrails to block off-topic requests. ## LangGraph URL: https://builderbriefai.com/tools/langgraph/ Maker: LangChain | Category: Agent framework | Audience: Builders Summary: Library for building stateful, long-running agents as graphs, with persistence and human-in-the-loop. Pricing: Open source; paid LangGraph Platform/LangSmith Official site: https://www.langchain.com/langgraph Best for: Developers needing explicit control over agent state and steps; Long-running, human-in-the-loop workflows; Production agents with checkpoints Not for: Quick one-off scripts; Non-developers Pros: Fine-grained control flow; Persistence and human-in-the-loop support; Open source, integrates with LangSmith Cons: Steeper learning curve; More boilerplate than simple SDKs; Concepts change across versions Use cases: Approval workflow: A graph where the agent drafts, pauses for human approval, then executes.; Research agent: Nodes for search, summarize and critique, looping until quality passes.; Stateful assistant: Persist conversation state with a checkpointer and resume later. ## Model Context Protocol URL: https://builderbriefai.com/tools/mcp/ Maker: Anthropic (open standard) | Category: Protocol | Audience: Builders Summary: Open protocol for connecting AI apps and agents to tools and data sources through MCP servers. Pricing: Open standard, free Official site: https://modelcontextprotocol.io Best for: Connecting AI assistants to files, apps and databases; Vendors exposing their product to AI agents; Teams standardizing tool access Not for: Situations where untrusted servers could touch sensitive data Pros: Open standard with many clients and servers; One integration works across apps; Per-action approval in clients like Claude Cons: Server quality and security vary; Prompt-injection risk from external content; Config can be fiddly Use cases: Files: Filesystem server lets Claude summarize a contracts folder.; Wiki: Connect Notion so the assistant reads specs directly.; Developer tools: Connect issue trackers or monitoring so a coding agent can act on them. ## CrewAI URL: https://builderbriefai.com/tools/crewai/ Maker: CrewAI | Category: Agent framework | Audience: Builders Summary: Python framework for orchestrating role-based teams of agents. Pricing: Open source framework; paid enterprise platform Official site: https://www.crewai.com Best for: Developers prototyping role-based multi-agent teams; Content and research pipelines; People who like YAML-configured agents and tasks Not for: Simple single-agent tasks; No-code users Pros: Intuitive roles/tasks model; Open source; Quick scaffolding CLI Cons: Multi-agent runs can be slow and costly; Less low-level control than graph frameworks; Debugging agent conversations takes effort Use cases: Research crew: Researcher, writer and editor agents produce a cited brief.; Lead qualification: An analyst agent scores inbound leads against criteria.; Report generation: Agents gather data and draft a weekly report. ## Ollama URL: https://builderbriefai.com/tools/ollama/ Maker: Ollama | Category: Local models | Audience: Builders Summary: Run open-weight models locally with a simple CLI and API. Pricing: Free, open source Official site: https://ollama.com Best for: Running open models privately on your own machine; Development without API costs; Offline or sensitive workloads Not for: Tasks needing frontier-level reasoning; Low-RAM machines Pros: Free and open source; One-command model downloads; OpenAI-compatible endpoint Cons: Quality limited by model size and hardware; Default context is 4,096 tokens; No built-in auth if exposed on a network Use cases: Private summaries: Summarize confidential notes locally with a Modelfile-based summarizer.; OpenAI-compatible dev: Point OpenAI SDK code at http://localhost:11434/v1/.; Local classifier: Use a small model to tag emails in a self-hosted n8n workflow. ## OpenRouter URL: https://builderbriefai.com/tools/openrouter/ Maker: OpenRouter | Category: Model API | Audience: Builders Summary: One API for many LLM providers, with per-model pricing listed on the site. Pricing: Pay-as-you-go model credits Official site: https://openrouter.ai ## Lovable URL: https://builderbriefai.com/tools/lovable/ Maker: Lovable | Category: App builder | Audience: Builders Summary: Build full-stack web apps by chatting; popular with vibe coders. Pricing: Free tier; paid plans Official site: https://lovable.dev Best for: Non-developers building web apps and internal tools; Founders validating an idea fast; Designers turning concepts into working apps Not for: Complex, regulated production systems without engineering review; Native mobile apps Pros: Built-in backend (Lovable Cloud) with auth and database; Publish to a lovable.app address on every plan; You own the code Cons: Credits limit heavy iteration; Security needs review before sensitive data; No one-click migration between Cloud and your own Supabase Use cases: Internal tool: "Build an equipment request app with employee, manager and ops roles."; Landing page: "Create a landing page for a dog-walking service with a booking form."; Client portal: Add sign-in and a documents page backed by Lovable Cloud. ## v0 URL: https://builderbriefai.com/tools/v0/ Maker: Vercel | Category: App builder | Audience: Builders Summary: Generates React/Next.js UI and apps from prompts and deploys to Vercel. Pricing: Free tier; paid plans Official site: https://v0.app ## ChatGPT URL: https://builderbriefai.com/tools/chatgpt/ Maker: OpenAI | Category: Assistant | Audience: At Work Summary: General AI assistant with search, file analysis, projects and agent mode. Pricing: Free; paid Plus, Pro, Business, Enterprise Official site: https://chatgpt.com Best for: General writing, analysis and brainstorming at work; Analyzing files and spreadsheets; Teams wanting one assistant with many features Not for: Tasks requiring guaranteed factual accuracy without review; Sensitive data on plans or settings not approved by your company Pros: Free tier; Broad features: files, images, voice, search; Business plans with admin controls Cons: Can state wrong facts confidently; Best models and limits on paid plans; Check data controls for work use Use cases: Rewrite for an audience: "Rewrite this memo for a non-technical client, under 200 words, friendly but direct."; Spreadsheet analysis: Upload a CSV: "Find the top 5 products by margin and chart monthly trend."; Meeting prep: "Here is the client email thread. List open questions and propose an agenda." ## Claude URL: https://builderbriefai.com/tools/claude/ Maker: Anthropic | Category: Assistant | Audience: At Work Summary: AI assistant for writing, analysis and research, with projects and connectors to work apps. Pricing: Free; paid Pro, Max, Team, Enterprise Official site: https://claude.ai Best for: Long documents and careful writing; Analysis that needs nuance; Connecting to work tools via connectors/MCP Not for: Image generation; Tasks needing guaranteed accuracy without review Pros: Strong at long-form writing and reasoning; Large context for big documents; Connectors and MCP support Cons: Usage limits on each plan; No native image generation; Requires review like any model Use cases: Contract summary: Upload a PDF: "Summarize obligations, dates and renewal terms in a table."; Writing partner: "Edit this proposal for clarity. Keep my voice. Show changes as a list."; Projects: Create a Project with your style guide so every chat follows it. ## Gemini URL: https://builderbriefai.com/tools/gemini/ Maker: Google | Category: Assistant | Audience: At Work Summary: Google's AI assistant, also built into Gmail, Docs and other Workspace apps. Pricing: Free; paid Google AI plans Official site: https://gemini.google.com Best for: Google Workspace users; Research with Google search grounding; Multimodal tasks including images and video Not for: Teams not on Google tools wanting deep integrations elsewhere Pros: Integrated across Google Workspace; Free tier; Strong multimodal capabilities Cons: Best features tied to paid Google plans; Workspace features depend on admin settings; Answers need verification Use cases: Gmail help: Summarize a long thread and draft a reply in Gmail.; Docs drafting: "Draft a project brief from these notes" inside Google Docs.; Deep research: Ask for a research report with sources on a market question. ## Microsoft 365 Copilot URL: https://builderbriefai.com/tools/microsoft-copilot/ Maker: Microsoft | Category: Office AI | Audience: At Work Summary: AI assistant inside Word, Excel, PowerPoint, Outlook and Teams. Pricing: Paid add-on for Microsoft 365 business plans Official site: https://www.microsoft.com/microsoft-365/copilot ## Grok URL: https://builderbriefai.com/tools/grok/ Maker: xAI | Category: Assistant | Audience: At Work Summary: xAI's assistant with real-time search across the web and X. Pricing: Free; paid SuperGrok plans Official site: https://grok.com ## Perplexity URL: https://builderbriefai.com/tools/perplexity/ Maker: Perplexity AI | Category: AI search | Audience: At Work Summary: Answer engine that searches the web and cites sources. Pricing: Free; paid Pro and Enterprise Official site: https://www.perplexity.ai Best for: Research questions where you want sources; Quick market and competitor lookups; Replacing many search tabs Not for: Creative long-form writing; Questions requiring private company data Pros: Cited answers; Free tier; Fast Cons: Sources can be low quality; click through; Advanced research features on paid plans; Not a replacement for primary sources Use cases: Competitor scan: "What pricing tiers do the top 5 helpdesk tools list today? Cite sources."; Prospect prep: "Summarize recent news about [company] from the last 90 days."; Fact check: Paste a claim and ask for supporting and contradicting sources. ## NotebookLM URL: https://builderbriefai.com/tools/notebooklm/ Maker: Google | Category: Research | Audience: At Work Summary: Upload documents and get grounded summaries, Q&A and Audio Overviews. Pricing: Free; higher limits with Google AI plans Official site: https://notebooklm.google Best for: Studying or summarizing a set of your own documents; Turning sources into audio overviews; Students, researchers and trainers Not for: Open web research (it focuses on your sources) Pros: Answers grounded in your uploaded sources with citations; Free to start; Audio overviews Cons: Limits on sources per notebook; Not for live web research; Google account required Use cases: Onboarding pack: Upload policy docs; new hires ask questions with citations.; Audio overview: Generate an audio overview of a long report to listen on a commute.; Study guide: "Create a study guide and 10 quiz questions from these sources." ## Notion AI URL: https://builderbriefai.com/tools/notion-ai/ Maker: Notion | Category: Workspace AI | Audience: At Work Summary: AI built into Notion for writing, search across connected apps and meeting notes. Pricing: Included in Notion Business and Enterprise plans Official site: https://www.notion.com/product/ai ## Zapier Agents URL: https://builderbriefai.com/tools/zapier-agents/ Maker: Zapier | Category: Automation | Audience: At Work Summary: No-code AI agents that act across thousands of connected apps. Pricing: Free tier; paid Zapier plans Official site: https://zapier.com/agents Best for: Non-technical teams already using Zapier; Agents that act across thousands of apps; Simple always-on assistants Not for: Complex custom logic better suited to code; Cost-sensitive very high volume Pros: Huge app ecosystem; Plain-language setup; Integrates with existing Zaps Cons: Activity limits by plan; Less control than code; Agents need monitoring Use cases: Lead research agent: New form lead → agent researches the company → posts a summary to Slack.; Inbox helper: Agent drafts replies to routine requests for review.; Weekly report: Agent pulls metrics from apps and writes a summary. ## Granola URL: https://builderbriefai.com/tools/granola/ Maker: Granola | Category: Meeting notes | Audience: At Work Summary: AI notepad that enhances your own meeting notes using the call transcript. Pricing: Free tier; paid plans Official site: https://www.granola.ai ## Windsurf URL: https://builderbriefai.com/tools/windsurf/ Maker: Cognition | Category: AI code editor | Audience: Builders Summary: AI-native code editor with the Cascade agent for multi-file edits. Pricing: Free tier; paid Pro and Teams plans Official site: https://windsurf.com ## Devin URL: https://builderbriefai.com/tools/devin/ Maker: Cognition | Category: Coding agent | Audience: Builders Summary: Autonomous AI software engineer that works on tickets in its own cloud environment. Pricing: Paid plans, usage-based Official site: https://devin.ai ## Replit URL: https://builderbriefai.com/tools/replit/ Maker: Replit | Category: App builder | Audience: Builders Summary: Browser-based IDE with Replit Agent that builds and deploys apps from prompts. Pricing: Free tier; paid Core and Teams plans Official site: https://replit.com ## Bolt.new URL: https://builderbriefai.com/tools/bolt/ Maker: StackBlitz | Category: App builder | Audience: Builders Summary: Prompt-to-full-stack-app builder that runs in the browser. Pricing: Free tier; paid token plans Official site: https://bolt.new ## Cline URL: https://builderbriefai.com/tools/cline/ Maker: Cline | Category: Coding agent | Audience: Builders Summary: Open-source autonomous coding agent extension for VS Code. Pricing: Open source; bring your own API key Official site: https://cline.bot ## Aider URL: https://builderbriefai.com/tools/aider/ Maker: Aider | Category: Coding agent | Audience: Builders Summary: Open-source AI pair programming in the terminal that edits files in your git repo. Pricing: Free, open source Official site: https://aider.chat ## Gemini CLI URL: https://builderbriefai.com/tools/gemini-cli/ Maker: Google | Category: Coding agent | Audience: Builders Summary: Open-source AI agent that brings Gemini into the terminal. Pricing: Free tier with Google account; open source Official site: https://github.com/google-gemini/gemini-cli ## LangChain URL: https://builderbriefai.com/tools/langchain/ Maker: LangChain | Category: Agent framework | Audience: Builders Summary: Open-source framework for building LLM apps and agents with integrations. Pricing: Open source Official site: https://www.langchain.com ## LangSmith URL: https://builderbriefai.com/tools/langsmith/ Maker: LangChain | Category: Observability | Audience: Builders Summary: Tracing, evaluation and monitoring platform for LLM apps and agents. Pricing: Free Developer tier; paid Plus and Enterprise Official site: https://www.langchain.com/langsmith ## LlamaIndex URL: https://builderbriefai.com/tools/llamaindex/ Maker: LlamaIndex | Category: Agent framework | Audience: Builders Summary: Framework for building agents and RAG apps over your data; LlamaCloud for parsing. Pricing: Open source; paid LlamaCloud Official site: https://www.llamaindex.ai ## AutoGen URL: https://builderbriefai.com/tools/autogen/ Maker: Microsoft | Category: Agent framework | Audience: Builders Summary: Open-source framework from Microsoft for multi-agent applications. Pricing: Free, open source Official site: https://microsoft.github.io/autogen/ ## Pydantic AI URL: https://builderbriefai.com/tools/pydantic-ai/ Maker: Pydantic | Category: Agent framework | Audience: Builders Summary: Python agent framework built by the Pydantic team with type-safe outputs. Pricing: Free, open source Official site: https://ai.pydantic.dev ## Mastra URL: https://builderbriefai.com/tools/mastra/ Maker: Mastra | Category: Agent framework | Audience: Builders Summary: TypeScript framework for building AI agents, workflows and RAG. Pricing: Open source; paid cloud Official site: https://mastra.ai ## AI SDK URL: https://builderbriefai.com/tools/vercel-ai-sdk/ Maker: Vercel | Category: Agent framework | Audience: Builders Summary: TypeScript toolkit for building AI apps and agents across model providers. Pricing: Free, open source Official site: https://ai-sdk.dev ## n8n URL: https://builderbriefai.com/tools/n8n/ Maker: n8n | Category: Automation | Audience: At Work Summary: Workflow automation platform with AI agent nodes; self-host or cloud. Pricing: Free self-hosted; paid cloud plans Official site: https://n8n.io Best for: Technical ops teams wanting powerful, self-hostable automation; AI agent workflows with many integrations; Cost-sensitive high-volume automations Not for: Total beginners who want the simplest builder; Teams with no one to maintain workflows Pros: Self-hostable; Strong AI nodes; Code when you need it Cons: Steeper than Zapier; Self-hosting means maintenance; Cloud plans meter executions Use cases: Inbox triage: Gmail Trigger → Text Classifier → labels and draft replies.; Lead routing: Webhook form → enrich → assign in CRM → Slack alert.; AI agent: An AI Agent node that uses tools like Google Sheets and HTTP requests. ## Make URL: https://builderbriefai.com/tools/make/ Maker: Make | Category: Automation | Audience: At Work Summary: Visual automation platform for connecting apps, with AI agents. Pricing: Free tier; paid plans Official site: https://www.make.com Best for: Visual automation with branching and data mapping; Ops and marketing teams; Connecting many SaaS apps affordably Not for: Users wanting a pure natural-language agent Pros: Visual scenario builder; Large app library; Free tier for testing Cons: Operations/credits add up at volume; Complex scenarios get hard to read; Some learning curve Use cases: Meeting notes to CRM: Fireflies webhook → GraphQL → HubSpot note.; Lead capture: Form → enrich → CRM → Slack.; Content ops: New blog post RSS → AI summary → social drafts in a sheet. ## Relevance AI URL: https://builderbriefai.com/tools/relevance-ai/ Maker: Relevance AI | Category: Agent builder | Audience: At Work Summary: No-code platform to build and run teams of AI agents. Pricing: Free tier; paid plans Official site: https://relevanceai.com ## Lindy URL: https://builderbriefai.com/tools/lindy/ Maker: Lindy | Category: Agent builder | Audience: At Work Summary: Build AI assistants that handle email, meetings and workflows. Pricing: Free tier; paid plans Official site: https://www.lindy.ai ## Hugging Face URL: https://builderbriefai.com/tools/hugging-face/ Maker: Hugging Face | Category: Model hub | Audience: Builders Summary: Hub for open models, datasets and Spaces, plus inference endpoints. Pricing: Free; paid Pro, Team and compute Official site: https://huggingface.co ## GroqCloud URL: https://builderbriefai.com/tools/groq/ Maker: Groq | Category: Model API | Audience: Builders Summary: Fast inference API for open models on Groq LPUs. Pricing: Free tier; pay-as-you-go Official site: https://groq.com ## Together AI URL: https://builderbriefai.com/tools/together-ai/ Maker: Together AI | Category: Model API | Audience: Builders Summary: Cloud for inference and fine-tuning of open-source models. Pricing: Pay-as-you-go Official site: https://www.together.ai ## ElevenLabs URL: https://builderbriefai.com/tools/elevenlabs/ Maker: ElevenLabs | Category: Voice | Audience: At Work Summary: AI voice generation, text-to-speech, dubbing and voice agents. Pricing: Free tier; paid plans Official site: https://elevenlabs.io ## Vapi URL: https://builderbriefai.com/tools/vapi/ Maker: Vapi | Category: Voice agents | Audience: Builders Summary: Developer platform for building voice AI agents. Pricing: Usage-based pricing Official site: https://vapi.ai ## Midjourney URL: https://builderbriefai.com/tools/midjourney/ Maker: Midjourney | Category: Image | Audience: At Work Summary: AI image (and video) generation from text prompts. Pricing: Paid subscription plans Official site: https://www.midjourney.com ## Runway URL: https://builderbriefai.com/tools/runway/ Maker: Runway | Category: Video | Audience: At Work Summary: AI video generation and editing tools. Pricing: Free tier; paid plans Official site: https://runwayml.com ## HeyGen URL: https://builderbriefai.com/tools/heygen/ Maker: HeyGen | Category: Video | Audience: At Work Summary: AI avatar videos, translation and lip-sync. Pricing: Free tier; paid plans Official site: https://www.heygen.com ## Synthesia URL: https://builderbriefai.com/tools/synthesia/ Maker: Synthesia | Category: Video | Audience: At Work Summary: AI video platform with avatars for training and business video. Pricing: Free tier; paid plans Official site: https://www.synthesia.io ## Descript URL: https://builderbriefai.com/tools/descript/ Maker: Descript | Category: Video | Audience: At Work Summary: Edit video and podcasts by editing the transcript, with AI tools. Pricing: Free tier; paid plans Official site: https://www.descript.com ## Canva URL: https://builderbriefai.com/tools/canva/ Maker: Canva | Category: Design | Audience: At Work Summary: Design platform with Magic Studio AI features. Pricing: Free; paid Pro and Teams Official site: https://www.canva.com ## Gamma URL: https://builderbriefai.com/tools/gamma/ Maker: Gamma | Category: Presentations | Audience: At Work Summary: Generate presentations, docs and websites with AI. Pricing: Free tier; paid plans Official site: https://gamma.app ## Jasper URL: https://builderbriefai.com/tools/jasper/ Maker: Jasper | Category: Writing | Audience: At Work Summary: AI content platform for marketing teams. Pricing: Paid plans with free trial Official site: https://www.jasper.ai ## Copy.ai URL: https://builderbriefai.com/tools/copy-ai/ Maker: Copy.ai | Category: Writing | Audience: At Work Summary: GTM AI platform for sales and marketing workflows. Pricing: Free tier; paid plans Official site: https://www.copy.ai ## Grammarly URL: https://builderbriefai.com/tools/grammarly/ Maker: Grammarly | Category: Writing | Audience: At Work Summary: AI writing assistance across apps. Pricing: Free; paid Pro plans Official site: https://www.grammarly.com ## Otter.ai URL: https://builderbriefai.com/tools/otter/ Maker: Otter.ai | Category: Meeting notes | Audience: At Work Summary: AI meeting notes, transcription and meeting agent. Pricing: Free tier; paid plans Official site: https://otter.ai ## Fireflies.ai URL: https://builderbriefai.com/tools/fireflies/ Maker: Fireflies.ai | Category: Meeting notes | Audience: At Work Summary: AI notetaker that records, transcribes and summarizes meetings. Pricing: Free tier; paid plans Official site: https://fireflies.ai Best for: Teams that want automatic meeting notes across Zoom, Meet and Teams; Pushing summaries into CRMs and tools; Searchable meeting archives Not for: Meetings where recording is not permitted or consented Pros: Automatic notes and action items; API and webhooks; Many integrations Cons: Bot in meetings can feel intrusive; Consent/recording laws vary; Advanced features on paid plans Use cases: CRM notes: Webhooks V2 meeting.summarized → Make → HubSpot note.; Action items: Share auto-generated action items to Slack after each call.; Search: "What did the client say about budget last month?" across transcripts. ## Fathom URL: https://builderbriefai.com/tools/fathom/ Maker: Fathom | Category: Meeting notes | Audience: At Work Summary: AI notetaker for Zoom, Google Meet and Teams. Pricing: Free tier; paid plans Official site: https://www.fathom.ai ## Clay URL: https://builderbriefai.com/tools/clay/ Maker: Clay | Category: Sales | Audience: At Work Summary: Data enrichment and AI research agents for go-to-market teams. Pricing: Free tier; paid plans Official site: https://www.clay.com Best for: Outbound and growth teams personalizing at scale; Combining many data providers; AI research per account Not for: Tiny lists you can research by hand; Teams without a clear ideal customer profile Pros: Many data providers in one table; AI research agents; Flexible integrations Cons: Credit-based costs add up; Learning curve; Data quality still needs checks Use cases: Waterfall emails: Find work emails across multiple providers, then verify.; Claygent research: "Does this company list open support roles? Give the URL or Unknown."; Personalized first lines: AI column writes one sentence from verified research. ## Apollo.io URL: https://builderbriefai.com/tools/apollo/ Maker: Apollo.io | Category: Sales | Audience: At Work Summary: B2B sales platform with contact data and AI outreach. Pricing: Free tier; paid plans Official site: https://www.apollo.io ## HubSpot Breeze URL: https://builderbriefai.com/tools/hubspot-breeze/ Maker: HubSpot | Category: Sales | Audience: At Work Summary: AI agents and assistant built into HubSpot CRM. Pricing: Included in HubSpot plans Official site: https://www.hubspot.com/products/artificial-intelligence ## Elicit URL: https://builderbriefai.com/tools/elicit/ Maker: Elicit | Category: Research | Audience: At Work Summary: AI research assistant for searching and summarizing papers. Pricing: Free tier; paid plans Official site: https://elicit.com ## Consensus URL: https://builderbriefai.com/tools/consensus/ Maker: Consensus | Category: Research | Audience: At Work Summary: AI search engine over peer-reviewed research. Pricing: Free tier; paid plans Official site: https://consensus.app ## Glean URL: https://builderbriefai.com/tools/glean/ Maker: Glean | Category: Enterprise search | Audience: At Work Summary: Work AI platform that searches across company apps. Pricing: Enterprise pricing Official site: https://www.glean.com ## Superhuman URL: https://builderbriefai.com/tools/superhuman/ Maker: Superhuman | Category: Email | Audience: At Work Summary: Fast email client with built-in AI. Pricing: Paid plans Official site: https://superhuman.com ## Airtable URL: https://builderbriefai.com/tools/airtable-ai/ Maker: Airtable | Category: Workspace AI | Audience: At Work Summary: App platform with AI fields and agents. Pricing: Free; paid plans Official site: https://www.airtable.com ## Follow Up Boss URL: https://builderbriefai.com/tools/follow-up-boss/ Maker: Follow Up Boss | Category: Real estate CRM | Audience: At Work Summary: Real estate CRM built for agents and teams: centralizes leads from many sources, automates follow-up and routes leads across a team. Pricing: Free trial; Grow plan $69/user/month billed monthly, larger team plans available Official site: https://www.followupboss.com ## Lofty URL: https://builderbriefai.com/tools/lofty/ Maker: Lofty | Category: Real estate CRM | Audience: At Work Summary: All-in-one real estate platform combining CRM, IDX websites, lead generation and AI agents for agents, teams and brokerages. Pricing: Paid; request pricing from Lofty Official site: https://lofty.com ## Restb.ai URL: https://builderbriefai.com/tools/restb-ai/ Maker: Restb.ai | Category: Real estate AI | Audience: At Work Summary: Computer-vision property intelligence for real estate companies: photo tagging, condition and feature detection for listings, MLSs and valuations. Pricing: B2B; contact sales Official site: https://restb.ai ## Virtual Staging AI URL: https://builderbriefai.com/tools/virtual-staging-ai/ Maker: Virtual Staging AI | Category: Real estate AI | Audience: At Work Summary: Upload a photo of an empty room and get AI-furnished staging in seconds, in a choice of room types and styles. Pricing: Free to try; paid plans advertised from about $1 per image Official site: https://www.virtualstagingai.app ## BoxBrownie URL: https://builderbriefai.com/tools/boxbrownie/ Maker: BoxBrownie.com | Category: Real estate AI | Audience: At Work Summary: Real estate photo editing, virtual staging, floor plans and renders, delivered by a team of digital editors, typically within 24 hours. Pricing: Pay per image or service Official site: https://www.boxbrownie.com # Categories - Coding agent (https://builderbriefai.com/category/coding-agent/): Claude Code, Codex, Devin, Cline, Aider, Gemini CLI - AI code editor (https://builderbriefai.com/category/ai-code-editor/): Cursor, Windsurf - Coding assistant (https://builderbriefai.com/category/coding-assistant/): GitHub Copilot - Agent framework (https://builderbriefai.com/category/agent-framework/): OpenAI Agents SDK, LangGraph, CrewAI, LangChain, LlamaIndex, AutoGen, Pydantic AI, Mastra, AI SDK - Protocol (https://builderbriefai.com/category/protocol/): Model Context Protocol - Local models (https://builderbriefai.com/category/local-models/): Ollama - Model API (https://builderbriefai.com/category/model-api/): OpenRouter, GroqCloud, Together AI - App builder (https://builderbriefai.com/category/app-builder/): Lovable, v0, Replit, Bolt.new - Assistant (https://builderbriefai.com/category/assistant/): ChatGPT, Claude, Gemini, Grok - Office AI (https://builderbriefai.com/category/office-ai/): Microsoft 365 Copilot - AI search (https://builderbriefai.com/category/ai-search/): Perplexity - Research (https://builderbriefai.com/category/research/): NotebookLM, Elicit, Consensus - Workspace AI (https://builderbriefai.com/category/workspace-ai/): Notion AI, Airtable - Automation (https://builderbriefai.com/category/automation/): Zapier Agents, n8n, Make - Meeting notes (https://builderbriefai.com/category/meeting-notes/): Granola, Otter.ai, Fireflies.ai, Fathom - Observability (https://builderbriefai.com/category/observability/): LangSmith - Agent builder (https://builderbriefai.com/category/agent-builder/): Relevance AI, Lindy - Model hub (https://builderbriefai.com/category/model-hub/): Hugging Face - Voice (https://builderbriefai.com/category/voice/): ElevenLabs - Voice agents (https://builderbriefai.com/category/voice-agents/): Vapi - Image (https://builderbriefai.com/category/image/): Midjourney - Video (https://builderbriefai.com/category/video/): Runway, HeyGen, Synthesia, Descript - Design (https://builderbriefai.com/category/design/): Canva - Presentations (https://builderbriefai.com/category/presentations/): Gamma - Writing (https://builderbriefai.com/category/writing/): Jasper, Copy.ai, Grammarly - Sales (https://builderbriefai.com/category/sales/): Clay, Apollo.io, HubSpot Breeze - Enterprise search (https://builderbriefai.com/category/enterprise-search/): Glean - Email (https://builderbriefai.com/category/email/): Superhuman - Real estate CRM (https://builderbriefai.com/category/real-estate-crm/): Follow Up Boss, Lofty - Real estate AI (https://builderbriefai.com/category/real-estate-ai/): Restb.ai, Virtual Staging AI, BoxBrownie