Rfp Respond

rfp-respond — Step 3: Parallel Team Processing

Retrieval-first drafting with confidence tiers, team routing, and built-in guardrails.

1. Purpose

This skill is the execution engine for Step 3 of the RFP Agent Swarm workflow. It converts a parsed, routed task list into a responses.json artifact in which every question carries a draft answer, a confidence tier (HIGH / MEDIUM / LOW), a source reference, and a reviewer flag where relevant.

It is built around one non-negotiable principle: retrieval over generation. For every question the answer bank (rfp-answer-bank) is searched first. Only if no acceptable match exists does the system generate — and when it does, the answer is flagged, capped at 75 confidence, and never shipped without human review.

It is the only skill in the swarm that writes answer text. Downstream skills verify, assemble, and submit; they do not re-draft.

2. When to Use

Trigger phrases (≥8):

• "draft RFP responses"
• "answer RFP questions"
• "write the security section"
• "respond to this questionnaire"
• "fill in the RFP answers"
• "draft security questionnaire responses"
• "answer the technical questions"
• "complete the commercial section"
• "run team drafting"
• "generate first-pass responses"

Do NOT use for…

3. Inputs

If any required input is missing the skill halts and emits a structured error naming the missing artefact. It never invents inputs.

4. Outputs

responses.json schema (one row per question):

{
  "question_id": "Q-042",
  "team": "security",                     // security | technical | commercial
  "consulted_teams": ["technical"],
  "tier": "MEDIUM",                       // HIGH | MEDIUM | LOW
  "confidence": 82,                       // 0-100, capped at 75 if generated
  "response_text": "…",
  "source": {
    "bank_entry_id": "BANK-0917",
    "last_approved_date": "2026-02-11",
    "original_question": "…",
    "delta_summary": "tightened wording; scoped to EU data residency"
  },
  "flags": ["REVIEWER_REQUIRED"],
  "reviewer_required": true
}

5. Retrieval-First Workflow

 For each question in task_list.json:
   │
   ├── 1. Call rfp-answer-bank/scripts/search_bank.py
   │       (hybrid: keyword + vector + semantic reranker)
   │
   ├── 2. scripts/confidence_scorer.py → tier + confidence
   │
   ├── 3. Decision tree (scripts/draft_responses.py):
   │        HIGH   → verbatim reuse; log source
   │        MEDIUM → adapt within allowed edits (see playbook)
   │                 record delta_summary
   │        LOW    → emit placeholder + FLAG_FOR_GENERATION
   │                 cap confidence ≤ 75
   │                 attach preamble (assets/)
   │
   ├── 4. scripts/route_to_specialists.py assigns PRIMARY team
   │       and CONSULTED teams
   │
   └── 5. Append row to working/responses.json (atomic write)

See references/retrieval-first-playbook.md for the full playbook including query formulation rules, re-query triggers, and worked examples for each tier.

6. Confidence Tiers

Rules enforced by scripts/confidence_scorer.py:

1. No generated response may exceed 75 confidence, ever.
2. Only a human (via rfp-review) may promote a tier.
3. Every response carries bank_entry_id (or GENERATED) and last_approved_date.

Full rules and rationale: references/confidence-tier-rules.md.

7. Team Routing Matrix

Routing is deterministic, driven by tags emitted by rfp-intake. See references/team-specialist-guides.md for per-agent responsibilities and handoff rules.

8. Guardrails

9. How to Invoke

# 1. Route (partitions task list into team queues)
python scripts/route_to_specialists.py \
  --task-list working/task_list.json \
  --output working/team_queues.json

# 2. Score each bank search result
python scripts/confidence_scorer.py \
  --search-result working/bank_search_results.json \
  --output working/confidence.json

# 3. Draft
python scripts/draft_responses.py \
  --task-list working/task_list.json \
  --bank-search-results working/bank_search_results.json \
  --output working/responses.json

All three emit JSON to stdout as well as the --output path, so they chain cleanly in Copilot Studio flows.

Progress card (rendered inline):

• Per-team progress: Security N/M, Technical N/M, Commercial N/M
• Confidence distribution donut (HIGH / MEDIUM / LOW counts)
• Flag count (reviewer_required = true)

10. Troubleshooting

Built-In Skills Used

Audit Log

Every meaningful step of the drafting run is appended to output/rfp-<rfp_id>/audit-log.xlsx via the shared Excel skill. This gives rfp-gates and rfp-review a complete, replayable record of what the swarm decided and why.

Schema and append helper:

• audit-log-schema.md — canonical column order, enums, and validation rules
• append_audit.py — idempotent appender used by every RFP skill

Every response row ALSO carries a provenance_id (either the matched kb_entry_id or the literal string generated+needs_review). That provenance_id is preserved verbatim through rfp-gates, rfp-review, and rfp-assemble so the final deliverable can be traced, row-for-row, back to an approved bank entry or a flagged generation event.

Adaptive Card Dashboard

Rendered inline via the Cowork Adaptive Cards built-in skill. The card is refreshed as each team's batch progresses so reviewers can watch the swarm work in real time.

Live progress card (refreshed as drafts complete):

• Three per-team progress bars — Security, Technical, Commercial — each showing % complete and a rolling ETA based on current throughput
• Current batch size and elapsed time per team

On batch complete, the card expands to include:

• KPI row — total drafted, HIGH %, MEDIUM %, LOW/flagged %
• Donut — confidence tier distribution across the full run
• Table — flagged questions (LOW tier + any generated response): question_id, team, reason, preview (first 140 chars)
• Call-to-action button — "Run the three quality gates" which invokes rfp-gates

The card is the primary human touch point for the drafting step; everything it shows is also written to responses.json and the audit log, so nothing displayed here is a separate source of truth.

11. Related Skills

RFP chain

rfp-intake → rfp-fit-assessment → THIS SKILL (rfp-respond) → rfp-gates → rfp-review → rfp-assemble

rfp-answer-bank sits underneath the entire chain as the shared substrate — every drafting, gating, and review decision resolves through it.

This skill is the heavy-compute step in the chain. It reads the task list from rfp-intake, queries rfp-answer-bank on every single question (retrieval-first), stamps each row with a provenance_id (KB entry or generated+needs_review), and then hands off a complete responses.json to rfp-gates. No other skill in the chain writes answer text; no other skill fans out across three specialist teams in parallel.

Cowork built-ins leveraged

• Excel — append to the run's audit-log.xlsx; read any authorised pricing input workbook
• Adaptive Cards — render the live progress dashboard, KPI row, tier donut, and flagged-questions table
• Enterprise Search — fallback retrieval when the answer bank misses, before falling through to generation
• Deep Research — escalation path for novel technical questions that neither the bank nor enterprise search can ground
• Word / PDF — read reference material (playbooks, MSAs, whitepapers, prior-submission exhibits) cited while drafting
• Communications — brief team leads on flagged items and notify them when a batch completes

Peer and chain skills

12. File Index