---
title: "Using AI to write RFP proposals: inside Mojar's drafting engine"
description: "How Mojar's RFP drafting engine turns your knowledge base and past proposals into a cited, gap-flagged first draft in minutes, drafted section by section."
datePublished: "2026-06-16"
dateModified: "2026-06-16"
author: "Adi Ghiuro"
image: "/assets/images/blog/marketing-sales/pestle-section-draft-review-gap.png"
imageAlt: "Mojar RFP drafting engine showing a drafted cover letter section beside a section review card that flags a gap in the company knowledge base"
intent: "commercial"
target_query: "AI RFP proposal writing"
estimated_reading_time: "13 min"
information_gain: "First-hand walkthrough of a working RFP drafting engine: how it reads a knowledge base before writing, scores evidence as found/partial/gap, flags missing data inline, and drafts each section in an isolated sub-agent. Includes real product screenshots and the gap-flagging contract that protects win rate."
tags:
  [
    "RFP Automation",
    "AI Proposal Writing",
    "Sales Efficiency",
    "RAG",
    "Revenue Operations",
  ]
keywords:
  [
    "AI RFP proposal writing",
    "RFP drafting software",
    "AI proposal writing tool",
    "RFP gap analysis",
    "write RFP response from knowledge base",
    "automated proposal drafting",
    "RFP response automation",
    "AI proposal generator with citations",
  ]
video:
  url: "https://www.youtube.com/watch?v=QfoNkgPCS5g"
  title: "Using AI to enhance proposal writing: 10x with the Mojar RFP drafting engine"
  description: "Watch Mojar's RFP drafting engine read a real knowledge base, build a cited response plan, flag gaps against the RFP, and draft a full proposal section by section."
  thumbnailUrl: "https://i.ytimg.com/vi/QfoNkgPCS5g/hqdefault.jpg"
  duration: "PT3M37S"
  uploadDate: "2026-06-15T00:00:00Z"
faq:
  - question: "Can AI actually write a full RFP proposal, not just retrieve answers?"
    answer: "Yes, with a caveat that matters. Mojar's RFP drafting engine writes complete proposal sections, cover letter, scope of service, compliance statements, and more, but every claim is grounded in your indexed documents and cited back to the source. It is not generic generation from training data. The engine searches your knowledge base first, drafts from what it finds, and marks anything it cannot support so a human fills the gap before submission."
  - question: "How does the engine flag gaps between RFP requirements and our company data?"
    answer: "Gap flagging runs on three layers. During planning, each requirement is scored as Found, Partial, or Gap based on what the knowledge base actually contains. While drafting, the writer leaves an inline marker like [GAP - needs SOC 2 report date] in the exact spot the evidence is missing. The orchestrator then collects those markers and pauses to ask you a focused question instead of inventing an answer. Nothing slips through as confident-but-fabricated text."
  - question: "Does it use our past winning and losing proposals?"
    answer: "Yes. The engine draws on your indexed knowledge base, which can include past proposal wins, well-written losses, product docs, compliance language, and case studies. Strong past responses become reusable evidence the engine can cite. Losses with good content still hold useful framing and language the engine can pull from."
  - question: "How is this different from pasting an RFP into ChatGPT?"
    answer: "Generic chat models generate plausible text from training data and will confidently invent your pricing, certifications, and references. Mojar retrieves from your approved content, cites every source, drafts one section at a time in a dedicated sub-agent so quality holds across a long document, and flags missing evidence rather than guessing. The output is traceable and reviewable, not a black box."
  - question: "Do we have to reorganize our documents before using it?"
    answer: "No. The knowledge base is indexed for semantic search, so the engine finds relevant passages by meaning, not folder structure. You connect your sources, the content gets indexed, and the engine runs similarity search across everything when it builds a plan or drafts a section."
  - question: "Who is the RFP drafting engine for?"
    answer: "Proposal writers, sales engineers, and bid managers who spend days assembling responses from scattered content. The engine removes the blank-page grind and the document hunt so the team can focus on win themes, pricing strategy, and review rather than copy-paste assembly."
related:
  - title: "RFP automation solution"
    url: "/rfp-automation"
  - title: "AI-powered RFP response automation: what actually works"
    url: "/blog/marketing-sales/ai-rfp-response-automation"
  - title: "Sales reps spend 20-30% on RFPs: the real cost"
    url: "/blog/marketing-sales/rfp-time-cost-sales"
  - title: "RAG for marketing and sales: the complete guide"
    url: "/blog/marketing-sales/rag-marketing-sales-complete-guide"
  - title: "RFP ROI calculator"
    url: "/free-tools/rfp-roi-calculator"
---

On most RFP responses, the writing happens last. The days disappear into everything that comes first: someone hunts through old proposals, finds the current compliance language, confirms which case study is approved, and checks whether the pricing in last quarter's deck still holds. Industry research puts RFP and proposal work at 20 to 30 percent of seller time, and the bulk of that is assembly and search, not original thinking ([Salesforce State of Sales](https://www.salesforce.com/resources/research-reports/state-of-sales/), [Loopio](https://loopio.com/)). We broke the dollar cost of that down in [our analysis of RFP time](/blog/marketing-sales/rfp-time-cost-sales), and the figure lands between $320K and $500K a year in direct labor for a 20-rep team.

I'm Adi Ghiuro, co-founder at Mojar, and over the past months our team built an RFP drafting engine that attacks the whole workflow, not just the search step. This post is a practitioner's walkthrough of how it works inside the platform: how it reads your knowledge base before it writes anything, how it scores evidence, how it drafts a real proposal section by section, and the part I care about most, how it flags the gaps between what an RFP asks for and what your company can actually prove.

![Mojar RFP drafting engine showing a drafted cover letter section beside a section review card that flags a gap against the knowledge base](/assets/images/blog/marketing-sales/pestle-section-draft-review-gap.png)

## The real bottleneck in RFP responses

When we deployed retrieval with sales teams, the pattern repeated everywhere, and we've seen it hold across every organization we work with. The work that swallowed reps' time was coordination, not writing: locating the right SOC 2 statement, confirming the latest insurance limits, tracking down who signs the cover letter, reconciling pricing across three documents that disagreed. The Association of Proposal Management Professionals ([APMP](https://www.apmp.org/)) has long documented that proposal teams lose disproportionate time to content management rather than strategy.

A retrieval system fixes the search. That was the focus of [our earlier piece on RFP response automation](/blog/marketing-sales/ai-rfp-response-automation), where the core point was that AI eliminates the hunt while the human still writes. The drafting engine is the next step in that evolution. It still retrieves and cites, but now it also assembles the first draft, so the human moves from author to editor.

## What the Mojar RFP drafting engine actually does

At a high level, the engine runs a two-phase workflow over your indexed content. It plans first, then it writes. Both phases are evidence-first: the system will not produce a plan or a section until it has actually searched your knowledge base for supporting material.

![RFP agent workflow pipeline: an uploaded RFP or PDF is parsed into cited requirements, then into a cited response plan, then into drafted sections one per turn, with knowledge base similarity search feeding each stage and gaps flagged throughout](/assets/images/blog/marketing-sales/rfp-agent-workflow-engine-pipeline.png)

Every box is a versioned artifact, and every arrow is a skill the agent loads on demand. An RFP agent ships with the default skill set below, taken straight from the configuration screen.

```text
General skills
  general.ask-user          ask a focused question when input would improve the work
  general.search-knowledge  find and inspect evidence from indexed documents
  general.navigate-knowledge browse the knowledge base as a folder tree
  general.memory-recall     recall facts and decisions from past sessions
  general.memory-store      save a long-lived preference or decision
  general.artifact-create   produce a deliverable the user can keep and version
  general.artifact-update   add a new version to an existing artifact
  general.read-artifact     fetch the current content of an artifact

RFP skills
  rfp.build-response-plan   turn an RFP into structured requirements and a cited plan
  rfp.execute-response-plan draft the proposal one section at a time via sub-agents
  rfp.scratchpad            capture corrections, decisions, and gaps for this draft
```

![Mojar agent configuration screen showing the RFP industry preset, system prompt mode, and tone of voice settings](/assets/images/blog/marketing-sales/pestle-configure-skills-prompt-tone.png)

## Step 1: turning an RFP into structured requirements

You start by attaching the RFP, a tender PDF, a scope-of-work document, or a question list. The agent recognizes the document type and loads the `build-response-plan` skill. Before it writes a single requirement, it does the research.

### How the engine reads your knowledge base before it writes

The screenshot below is the engine's own thought process while building a plan for a real investment-consulting RFP. You can see it load three skills, recall prior context with `memory-recall`, run a `batch-similarity-search` across the knowledge base, and jot working notes with `scratchpad-note` before it commits to anything.

![Mojar thought process panel showing skills loaded, memory recall, an 8-query batch similarity search, and a scratchpad note while building a response plan](/assets/images/blog/marketing-sales/pestle-thought-process-build-plan.png)

That batch search is the part most tools skip. Rather than one vague query, the engine fans out multiple targeted queries, one per capability area the RFP touches, and ranks the hits against your actual files. In the expanded view you can see queries like "firm overview history ownership fiduciary SEC registered investment adviser" and "asset allocation capital market expectations portfolio optimization" returning ranked matches against documents such as `07-compliance-ethics.md` and `05-research-capabilities.md`, each with a similarity score.

![Expanded similarity search results showing multiple ranked queries with percentage match scores against named knowledge base files](/assets/images/blog/marketing-sales/pestle-knowledge-base-similarity-search.png)

This is how the engine grounds itself in your content rather than its training data. Every requirement it writes traces back to a passage it actually retrieved.

### Evidence status: found, partial, gap

The output of this phase is a Requirements artifact. Each requirement carries an evidence status, and this is where the engine starts earning trust:

- **Found**: the knowledge base contains strong, directly relevant evidence.
- **Partial**: there is related material, but it is incomplete or needs confirmation.
- **Gap**: the RFP asks for something your indexed content does not cover.

That three-way split is deliberate. A tool that only says "done" hides risk. Marking a requirement as a gap up front, before drafting, tells the proposal lead exactly where a human needs to supply a number, a certification date, or an authorization letter.

## Step 2: the cited response plan

Once requirements are scored, the engine builds a Response Plan: the section-by-section blueprint a writer would normally assemble by hand. Each planned section references the evidence it will draw on, so the plan maps to your content instead of to a generic template.

In the demo we recorded, that plan came back with 13 sections to draft for a single RFP, from the cover letter through required statements and appendices. The plan is its own artifact, which means you can read it, edit it, and approve it before any drafting starts. We recommend treating the plan as a checkpoint: it is far cheaper to fix structure here than after 13 sections exist.

## Gap flagging: the feature that protects your win rate

This is the part that matters most. The most damaging RFP error is a confident, fabricated answer: the kind a procurement team catches in review, or worse, the kind you discover only after you win and cannot deliver. Generic AI produces these constantly because it is built to always answer. Mojar's engine is built to do the opposite and refuse to fake it.

### How a gap surfaces in the draft

While a section is being written, the writer does not paper over missing evidence. It leaves an explicit inline marker at the exact spot the data is missing, in a format the system can detect:

```text
(b) Illinois State Board of Elections Business Entity Registration

Pinnacle Advisory Group, LLC certifies that:
[Pinnacle is / is not] registered as a business entity with the Illinois State
Board of Elections pursuant to the Procurement Code.
[GAP - needs SBE registration status and certificate number]
```

You can see this in the live product. In the section-review screenshot earlier, the drafted cover letter contains bracketed placeholders and a flagged note where the firm's exact registration details belong. The engine drafted everything it could prove and stopped precisely where your input is required.

### When the engine asks instead of guesses

The orchestrator collects every `[GAP]` marker from a finished section. If the list is not empty, instead of moving on it pauses and asks you a focused question through the `ask-user` skill. In the demo, the very first thing it asked was who should be named as the authorized signatory on the cover letter, because no document in the knowledge base named that person.

This is the behavior that makes the output submission-ready rather than a draft you have to fully fact-check. The `scratchpad` skill backs it up by recording gaps, corrections, and decisions for the whole drafting cycle, so a fix you make in section 2 is remembered when section 9 references the same fact. In practice, this turns review into a short list of named decisions rather than a line-by-line audit.

## Step 3: drafting sections with sub-agents

Long documents are where most AI drafting falls apart. Quality drifts, tone wanders, and section 12 forgets what section 1 promised. Our approach is to draft each section in its own isolated sub-agent.

When you trigger `execute-response-plan`, the engine works through the plan one section at a time. For each section it uses a `delegate_to_agent` tool to spin up a dedicated section-writer sub-agent. That sub-agent searches the knowledge base in depth for its specific section, drafts the prose with citations, leaves any gap markers, and emits the section as its own artifact. Then control returns to the orchestrator, which checkpoints the result and moves to the next section.

![Mojar artifact switcher showing the RFP section, response plan, and requirements artifacts for one RFP, with version v1 indicated](/assets/images/blog/marketing-sales/pestle-artifact-switcher.png)

Because every section is a versioned artifact, you can switch between Requirements, Response Plan, and any drafted section from one panel, compare versions, revise a single section without regenerating the rest, and export the result. When you ask for a change, the engine creates a new version (v2) rather than overwriting, and it preserves the citations as it edits. You can copy a section or download it as a Word document when you are ready to assemble the final response.

## Configuring the agent: skills, prompt mode, and tone of voice

The engine is configurable rather than a black box. On the configuration screen you control three things.

First, skills. You enable or disable each capability, and the agent only sees what is enabled. The general skills handle asking, searching, remembering, and artifact management; the RFP skills handle planning, execution, and the scratchpad.

![Mojar skills configuration showing toggles for general skills including ask user, create artifact, memory recall, navigate knowledge, read artifact, remember, search knowledge, and update artifact](/assets/images/blog/marketing-sales/pestle-general-skills-toggles.png)

![Mojar industry-specific skills showing build response plan, execute response plan, and RFP scratchpad with pinned toggles](/assets/images/blog/marketing-sales/pestle-rfp-skills-build-execute-scratchpad.png)

Second, system prompt mode. You can run Mojar's managed industry default, which is maintained for compliance, or switch to a fully custom prompt where you take responsibility for the agent's behavior end to end.

Third, tone of voice. You describe how the agent should write, or generate a tone profile from your own knowledge base. That profile applies to chat replies and to every drafted section, so the proposal reads like your firm wrote it. For example, a tone instruction might be "write in a formal, plain-spoken voice, prefer short sentences and active voice." We built this because a proposal in the wrong voice gets rewritten anyway, which defeats the speed gain.

## How this compares to manual work and generic AI

The table below is the comparison we use internally when teams ask why this beats both the status quo and a chatbot.

| Capability | Manual RFP process | Generic AI (ChatGPT) | Mojar RFP drafting engine |
|------------|--------------------|----------------------|---------------------------|
| Finds your approved content | Hours of manual search | Does not access your data | Semantic search across your knowledge base |
| Source citations | Manual, often skipped | None, invents sources | Every claim cited to a document |
| Handles missing data | Easy to overlook | Fabricates an answer | Flags a gap and asks you |
| Long-document quality | Depends on the writer | Drifts across sections | One sub-agent per section |
| Output format | Copy-paste assembly | Plain text | Versioned artifacts, Word export |
| Tone consistency | Varies by author | Generic | Tone profile applied to every section |

Unlike a generic model that answers everything to look complete, the engine treats a missing answer as information you need. The honest summary: a manual process is accurate but slow, a generic model is fast but unsafe, and the drafting engine is built to be fast and traceable at the same time. However fast it gets, the human still owns the final review.

## What the engine does not do

I would rather you trust the boundaries than oversell. The engine drafts from what you have indexed, so the quality of the output tracks the quality of your knowledge base. If your past proposals are thin, the gaps list will be long, which is useful information but not magic. The engine also does not make the final call on strategy, pricing, or which references to feature. It surfaces options and evidence; a human still owns the win themes and the submit button. And it is a drafting partner, not an approval workflow. Legal and compliance review still happen the way they always have, just on a draft that is already cited and gap-checked.

If you want the deeper background on how retrieval and citations work underneath all of this, [our complete guide to RAG for revenue teams](/blog/marketing-sales/rag-marketing-sales-complete-guide) covers the architecture in detail.

## See it in action

The fastest way to understand the engine is to watch it run. In the video, we attach a real RFP, the engine reads the knowledge base, builds a cited plan, flags the gaps, asks who signs the cover letter, and drafts the proposal section by section. By Mojar's own benchmark in that demo, the move from blank page to an advanced first draft happens in minutes rather than the days a manual response usually takes.

[Watch: using AI to enhance proposal writing with the Mojar RFP drafting engine (3:37)](https://www.youtube.com/watch?v=QfoNkgPCS5g)

If you respond to RFPs and want to see this against your own content, [book a demo](/schedule-demo) and we will run your real documents through the engine, or explore the full [RFP automation solution](/rfp-automation) first. Curious what the time savings are worth for your team? The [RFP ROI calculator](/free-tools/rfp-roi-calculator) will do the math, and you can schedule a demo whenever you are ready to try it on a live bid.
