Writing proposals is the tax you pay on winning work. A prospect emails “can you send me a quote?”, and 45 minutes later you’re still wrestling a template, copying numbers from your rate card, and second-guessing the scope paragraph. Multiply that by every lead and it’s the single biggest time sink in most service businesses.
An AI agent fixes the drafting part. Not the sending — you still want a human eye before anything leaves your domain — but the agent can take a messy inbound request and turn it into a clean, on-brand first draft with the right line items, priced correctly, in under a minute. We build these for ourselves and for clients, and below is exactly how, with no code.
What “an agent” actually means here
Be precise, because the word gets thrown around. A classic automation (a Zap, a Make scenario) follows fixed rules: if this email arrives, do these exact steps. An agent is given a goal and a set of tools, and it decides what to do — it reads the request, judges what’s being asked, pulls the relevant pricing, and writes prose that fits the situation. That judgement is precisely what proposal drafting needs, because no two inbound requests are phrased the same way.
For this job you genuinely want the agentic flavour. A rigid template-filler breaks the moment someone writes “we’d also need onboarding for about 12 people” instead of ticking a box. A good LLM-backed agent handles that variation gracefully.
The four pieces every proposal agent needs
- A trigger — where the request comes in. A specific inbox label, a website form, a Slack message, or a row added to a sheet.
- Your pricing knowledge — the rate card, package tiers, and rules the agent must price against. This is the part people skip, and it’s the part that decides whether the output is usable.
- The drafting brain — the LLM with a tight instruction set that turns request + pricing into a structured draft.
- An output destination — where the draft lands for your review: a proposal tool, a Google Doc, or a reply draft sitting in your outbox (never auto-sent).
Step by step: building it
1. Pin down the pricing source first
Before touching any agent builder, put your pricing somewhere the agent can read. A plain Google Sheet works beautifully: one row per service, columns for name, unit, rate, typical scope notes. Add a second tab for package bundles (“Starter / Growth / Pro”) with what each includes.
The reason this comes first: an LLM left to its own devices will invent prices. It will confidently quote $2,500 for something you charge $4,000 for. Grounding it in a real rate card is the difference between a tool you trust and a liability. Make the sheet the single source of truth and tell the agent, in plain words, that it may only use numbers found there.
2. Choose your builder
Three honest paths, depending on how much you already use and how much control you want:
| Path | Best when | Watch out for |
|---|---|---|
| Zapier Agents | You want the fastest start. You describe the agent in plain English, connect your inbox + sheet, and it runs across thousands of apps. Lowest learning curve. | Cost scales with task volume; less visual insight into why a step ran. |
| Make | You want to see the logic on a canvas and add branching (e.g. small deals → quick quote, big deals → full proposal). Cheaper per operation at volume. | More moving parts to wire up; steeper first hour. |
| A proposal tool’s built-in AI (PandaDoc, Better Proposals) | You already live in that tool and mostly need polished, branded output with e-sign and tracking baked in. | The “agent” is shallow — great formatting, weaker at reasoning over a messy inbound request. Often an extra-cost tier. |
For a first build, Zapier Agents or Make. If proposals are your whole business and you need legally-binding e-signatures and open-tracking, pair the agent with a dedicated tool: agent writes the draft, the proposal platform handles delivery and signing. PandaDoc and Better Proposals both start around $20/user/month, but the genuinely useful automation and API features tend to sit a tier or two up, so check the limits before you commit.
3. Write the agent’s instructions
This is where most of the quality lives. Treat it like onboarding a new sales assistant — be specific about what good looks like. A working instruction set reads roughly like this:
- Role: “You draft proposals for a [web design] studio. You never send anything; you only prepare a draft for a human to review.”
- Inputs: “Read the incoming request. Extract: client name, what they’re asking for, team size or scale if mentioned, and any deadline.”
- Pricing rule: “Match the request to line items in the Pricing sheet. Use only rates from that sheet. If something is requested that isn’t on the sheet, add it as a line marked [NEEDS PRICING] rather than guessing.”
- Structure: “Output: a one-line summary of understood scope, an itemised quote table with quantities and a total, a short ‘what’s included’ paragraph, and a ‘what’s not included’ note.”
- Tone: “Confident, plain, no jargon. Match the warmth of our brand. Don’t overpromise timelines.”
That [NEEDS PRICING] flag is the safety valve. Instead of the agent fabricating a number, it raises its hand — and you fill the gap in ten seconds during review. It turns the agent’s biggest weakness into a visible, fixable note.
4. Set the output to land in “review” state
Route the finished draft to a Google Doc, a Notion page, or — best for sales flow — a draft reply in your email client. Most email integrations have a “create draft” action distinct from “send”. Use it. You get a ready-to-go message sitting in your drafts folder; you skim it, fix the flagged lines, adjust a sentence, and hit send yourself.
This single design choice is what makes the whole thing safe to run on real clients. The agent does 90% of the work; you keep the 10% that carries the legal and relationship risk.
5. Test on ten real past requests
Don’t go live on a hypothetical. Take ten genuine inbound emails you’ve already answered, feed them through, and compare the agent’s draft to what you actually sent. You’ll spot the patterns fast: maybe it’s too verbose, maybe it forgets to mention revisions are limited, maybe it under-scopes enterprise deals. Tighten the instructions and re-run. Three rounds usually gets it to “I’d send this with minor edits”.
When this is NOT the right tool
Honesty matters more than selling you on automation:
- Highly bespoke, high-stakes proposals. If every deal is a six-figure custom engagement negotiated over weeks, an agent’s generic draft adds little — you’re writing those by hand anyway, and should.
- Pricing that depends on a real conversation. If you can’t quote until you’ve done a discovery call, the agent can’t either. It can prep the structure and a draft scope, but leave the numbers blank.
- Regulated or contractual language. Agents draft; they don’t do legal review. Anything binding still needs human (and sometimes legal) sign-off.
- You have under ~5 proposals a month. Be honest about ROI. The setup and tuning take a few hours. If you’re sending two quotes a month, a good saved template plus a sharp brain is faster than maintaining an agent.
The sweet spot is a steady stream of small-to-mid quotes that are similar in shape but different in detail. That’s where an agent pays for itself within the first week.
FAQ
Will the AI invent prices or make things up?
It can, which is exactly why you ground it in a rate-card sheet and forbid it from inventing numbers, with a [NEEDS PRICING] flag for anything it can’t find. Combined with mandatory human review before sending, hallucinated pricing never reaches a client. Never let a proposal agent send autonomously — drafting is safe to automate, sending is not.
How much does this cost to run?
The builder itself is the main cost. Zapier Agents and Make both have free tiers to prototype on, with paid plans scaling by task or operation volume — realistically tens of dollars a month for a small business’s proposal flow. If you add a dedicated proposal platform for e-signatures and tracking, budget roughly $20–50/user/month on top, and read the fine print, because bulk-send and API features often sit on higher tiers.
Can it handle my specific industry’s quote format?
Yes — the format lives entirely in your instructions and your template. The agent doesn’t care whether you’re quoting landscaping, software, or legal retainers; you tell it the line-item structure, the included/excluded sections, and the tone. The reasoning is general; the shape is whatever you define.
Your next step
Don’t build the whole thing today. Do one concrete thing this afternoon: open a Google Sheet and write out your rate card properly — every service, every rate, the package bundles. That single artifact is 80% of what makes a proposal agent good, and it’s useful even if you never automate. Once it exists, wiring up a Zapier or Make agent on top is an hour’s work, and you’ll have a draft-in-sixty-seconds machine running by the end of the week.