# How we draft RFP responses

The RFP-responder agent we run on Kortix — connected to the inbound RFP and our vetted answer library. It parses each question, drafts a response in a new Google Doc from the library and our product docs, and flags anything it can't answer confidently for a human to review before it goes out.

Canonical page: https://openchatly.com/use-cases/rfp-responder

An RFP or proposal questionnaire lands as a long document attached to an email —
pricing, implementation timeline, support model, integrations, company
background, references — and a submission deadline that doesn't move. Most of
it we've answered before, in a past proposal or a product doc, but it's scattered
across old submissions and no one remembers exactly where. A rep spends a day
combing through past deals and pinging product and support for lines that
already exist, before writing a single new sentence.

We run an RFP-responder agent on Kortix that drafts the response from our vetted
answer library the moment the RFP arrives. This is how we answer our own RFPs and
proposal questionnaires, including the connections and guardrails involved.

- **Team:** Kortix
- **Runs on:** Every 15 minutes
- **Connected systems:** Gmail · Google Drive · Google Docs
- **Mode:** Drafts only · a human reviews and submits

## The problem

Most of an RFP is questions we've answered dozens of times — pricing tiers,
implementation timeline, integrations, support SLAs, company background,
references — but each one arrives in its own document, a Word file, a PDF, a
vendor's own spreadsheet, with its own structure and its own deadline. Someone
has to read the whole thing, recall or dig up the answer we gave last time, and
write it back into that document's layout, all before the submission window
closes.

The shortcuts don't hold up. Copying the last similar proposal wholesale risks
carrying over stale pricing or a client-specific detail that doesn't apply here.
Searching a shared drive of past submissions by hand is slow and depends on
remembering which deal had the closest answer. A generic AI drafter with no
grounding writes something that reads well and is often wrong — on a document
that can become a contract exhibit, a confident wrong answer is worse than a
blank one.

## What we built

On Kortix, a cron checks the inbox every 15 minutes for a new RFP or proposal
questionnaire. Each check spawns a fresh session (a cloud sandbox) with access
to our vetted past-answers library, our product docs, and the incoming RFP
document. It parses the RFP into individual questions, matches each against the
library and the docs, drafts the full response in a new Google Doc, and flags
any question it can't answer confidently for a person. It never submits
anything — the draft is the only output, and a human reviews and submits it
through whatever channel the RFP requires.

## How it works

### Copy the setup prompt into a new session

Open your Kortix workspace, start a new session, paste this prompt and send it.
The agent writes the agent file, the rfp-response skill and the 15-minute
trigger, and opens a change request for you to review. Prefer clicks? Choose
**Use this template** instead.

**Setup prompt**

```
Set up an RFP responder agent in this workspace.

1. Create the agent agents/rfp-responder.md. Its job is to draft a full response to each new RFP or proposal questionnaire. It may use the Gmail, Google Drive and Google Docs connectors.

2. Create the skill skills/rfp-response/SKILL.md with these rules:
   - A thread under the Gmail label RFPs with no draft reply is new. Work the oldest one first, and respect any stated deadline.
   - Open the RFP document from Google Drive, read every section, and extract each question with its section, number and exact wording. Never edit, move or delete the source file.
   - Answer only from the vetted answers in memory/rfp-answers.md. Check each product-capability answer against the current product docs.
   - Write the response in a new Google Doc in the RFP Drafts folder, in the RFP's own order and headings.
   - Mark every question without a confident match NEEDS REVIEW, and list them at the top of the doc. Never invent an answer.
   - Leave an unsent Gmail draft reply on the thread that links the doc and lists what is flagged. Never send, submit or upload anything.

3. Add a cron trigger rfp-check to kortix.yaml. It runs the rfp-responder agent every 15 minutes with the prompt "Load the rfp-response skill and draft a response to every new RFP under the RFPs label."

4. Tell me which of these connectors are not connected yet.

5. Open a change request with all of it. Do not merge it.
```

### Connect your tools

Open **Connectors** in your workspace and connect the inbox where RFPs arrive,
Google Drive and Google Docs. Credentials are brokered server-side and never
enter the agent's machine.

- **Gmail** (Required):
Reads each new RFP and leaves an unsent reply draft.
- **Google Drive** (Required):
Opens the RFP document and saves the draft response Doc.
- **Notion** (Optional):
Supplies vetted past answers when the library lives there.

### Run it once with this prompt

Merge the change request, then start a session with the **rfp-responder** agent
and send this prompt. Read the first draft and its flagged questions before you
let the schedule take over.

**Prompt**

```
Draft a response to every new RFP under the Gmail label RFPs.

1. Find the threads under RFPs that have no draft reply.
2. Open each RFP document from Google Drive and extract every question with its section and number.
3. Answer each question from the vetted answers library, checked against the current product docs.
4. Write the response in a new Google Doc in RFP Drafts, in the RFP's order, and mark every unmatched question NEEDS REVIEW.
5. Leave an unsent Gmail draft reply on the thread with the doc link and the flagged list. Do not send or submit anything.
```

### Let the 15-minute schedule take over

The change request added this trigger to `kortix.yaml`. From now on the agent
runs every 15 minutes, each run in a new session on its own cloud computer. To
change the time, edit the cron line, or open **Triggers** in the workspace.

**kortix.yaml**

```yaml
triggers:
  - slug: rfp-check
    name: RFP inbox check
    on:
      cron: "0 */15 * * * *"
    run:
      agent: rfp-responder
      prompt: Load the rfp-response skill and draft a response to every new RFP under the RFPs label.
```

### Flag what it cannot answer, never submit

The agent answers only from the vetted library and flags every question without
a confident match. It never sends the reply, uploads to a buyer portal or
contacts the buyer. A person resolves the flags and submits the response.

### Read the draft response

Each new RFP gets one draft doc and one unsent reply on its thread. This is
what a run looks like in the session:

> **RFP inbox check · 09:45**
>
> Prompt: Load the rfp-response skill and draft a response to every new RFP under the RFPs label.
>
> Found **1** new RFP with **64** questions. Drafted **58** answers from the
> vetted library in a new doc in RFP Drafts. **6** questions are marked NEEDS
> REVIEW, most of them about data residency. An unsent reply with the doc link
> is on the thread.

> **The pattern**
> A 15-minute **cron** checks Gmail and spawns a fresh session with scoped
> **connectors** into Drive and Docs. The past-answers library lives as
> **skills** and **memory**. The agent drafts every answer it can and flags what
> it can't; a human reviews and submits.

## Make it do more

Once it works, paste any of these into the same session.

**Grow the answer library**

```
After a person rewrites a flagged answer in a draft, ask me whether to add it to memory/rfp-answers.md.
```

**Show the deadline**

```
Read the submission deadline from each RFP, and put it in the doc title and the first line of the draft reply.
```

**Weekly RFP status**

```
Every Friday, list each open RFP draft with its deadline and the number of questions that still need review.
```

## Guardrails

The agent drafts a document that can end up in front of a customer, so its
access is scoped and the output is contained:

- **Isolation.** Every check runs in its own isolated sandbox. The session reads
  only the RFP source and the answer library it's scoped to, and only the draft
  Google Doc is the output.
- **Scoped secrets.** The Gmail, Drive, and Docs credentials are encrypted in the
  Secrets Manager and injected into the sandbox at runtime, scoped to the agents you grant them to.
- **Draft only, never submitted.** The agent has no path to submit an RFP
  portal, send an email, or upload a file to the buyer. A human reviews the
  draft and submits it themselves.
- **Everything is code.** The agent's answer library, skills, and per-system
  permissions are files in the repo, versioned and changed through a reviewed
  **change request** rather than a dashboard setting.

## The outcome

- **Every 15 min:** Inbox checked for a new RFP or questionnaire
- **Grounded:** Every answer drawn from the vetted library and product docs
- **Draft only:** A human reviews and submits every response

RFPs that used to cost a rep a day of digging through old proposals now come back
as a completed draft within 15 minutes, with the vetted answer already in place
and the uncertain questions called out by name. The team spends its time on the
questions that actually need judgment, and nothing goes to a buyer without a
person reviewing and submitting it.
