The Operator’s Playbook: A Guide to Building Your Dynamic AI Proposal Team
The Philosophy Behind the Playbook
Welcome to your AI-powered workflow. You are about to configure and operate a team of five specialized AI assistants designed to act as your cognitive collaborators. This guide is more than a set of instructions; it is a transfer of the design philosophy we have developed together.
Our entire approach is built on one of the foundational beliefs from our Saliency Landscape: “Trust is Earned, Not Given.” This system is designed to be trustworthy through discipline. The key architectural principle in this version is:
1. Decoupling Logic from Data: Our specialist GPTs (CF00-CF04) have no permanent knowledge of any specific RFQ. Their expertise is in the process, which is defined by their instructions and knowledge files. We provide the scenario-specific data (the RFQ files) at the start of each session by attaching the files directly to the chat. This makes the system infinitely reusable and scalable for any RFQ you encounter.
This is enabled by our other core principles:
2. Process Decomposition (The “Case File” Method): We use a team of specialists. Each GPT has one job and does it well. This makes the process predictable, manageable, and auditable.
3. Structured Data Contracts (The “JSON Schema”): We enforce a strict JSON output by providing a schema in each GPT’s knowledge base. This makes the AI’s output 100% predictable and allows us to reliably “chain” the assistants together.
4. Chain-of-Thought (CoT) Reasoning: We force the AI to “think out loud” before it acts. This makes its logic transparent and allows you to validate its process, not just its final answer.
Your role in this workflow is that of the Chief Strategist and Final Arbiter. The AI assistants handle the toil; you provide the judgment. This playbook will teach you how to do exactly that.
Workshop files
Workflow Mechanics: How the Team Collaborates
This workflow is a “daisy chain” of specialized assistants. The output of one GPT becomes the input for the next. This is achieved by passing a structured JSON data file from one chat session to the next, while providing the necessary source documents as attachments in each step.
Your job as the operator is to manage the handoff of these JSON files and document attachments between your AI team members, validating their work at each step.
0️⃣ GPT 0: The Manifest Generator (CF00)
Purpose
This utility agent performs the essential “zeroth step”: it ingests a set of attached project files and produces a structured JSON manifest. This manifest becomes the standardized kickoff prompt for the rest of the workflow, ensuring a clean and error-free start.
GPT Instructions (The ‘Configure’ Tab)
You are the CF00 Manifest Generator. Your sole function is to take a collection of uploaded files and create a structured JSON manifest listing them, which will serve as the input for the main workflow.
**Your Process:**
1. When the user uploads files and asks you to create a manifest, you will list all the files you have access to.
2. For each file, you will create a JSON object containing its `fileName` and `fileId` (or its path if an ID is not available).
3. You will then bundle these objects into a single JSON array under a root key named "filePackage".
4. You will call the `createFileManifest` action with this JSON payload to formalize the output.
5. Finally, you will present the complete, formatted JSON to the user inside a code block, instructing them to copy it for use in the CF01 Triage Agent.
**CRITICAL RULE:** Your final output must be a single, valid JSON object that strictly adheres to the schema defined in your knowledge file `CF00_Schema.json`. Do not include any conversational text or explanations outside of the final JSON code block.
Knowledge Base Files (Process Only)
- (None required for this utility agent)
Operator’s Guide
- Setup:
- In your GPT builder interface, create a new GPT. Name it “CF00 Manifest Generator”.
- Navigate to the “Configure” tab and paste the full text from the “GPT Instructions” section above.
- Navigate to “Actions” and create a new action. Copy and paste the JSON schema from the “JSON Action Contracts” section below.
- Save the GPT. It is now ready to use.
- Usage:
- Start a new chat with the “CF00 Manifest Generator”.
- Upload the entire folder of RFQ documents for the project you wish to analyze.
- Use the below prompt.
- The GPT will return a JSON code block. Copy this entire block to your clipboard. This is the starting pistol for the main workflow and will be your first prompt to the CF01 agent.
Conversation Starter:
Your task is to facilitate the Manifest Generator process by executing the distinct action defined in your knowledgebase: 1) `createFileManifest.md`. Acknowledge your task instructions, then ask for the files.
JSON Action Contracts
Action: createFileManifest
{
"openapi": "3.1.0",
"info": {
"title": "Create File Manifest",
"description": "Creates a structured JSON manifest of a file package to be used as input for the RFQ workflow.",
"version": "v1.0.0"
},
"paths": {
"/createFileManifest": {
"get": {
"description": "Formats a list of files into a standard JSON manifest object.",
"operationId": "CreateFileManifest",
"parameters": [
{
"name": "filePackage",
"in": "query",
"description": "A JSON array where each object represents a file in the project package.",
"required": true,
"schema": {
"type": "array",
"items": {
"type": "object",
"properties": {
"fileName": {
"type": "string",
"description": "The full name of the file, including its extension."
},
"fileId": {
"type": "string",
"description": "The unique ID or accessible path for the file provided by the system."
}
}
}
}
}
]
}
}
}
}1️⃣ GPT 1: The Triage Agent (CF01)
Purpose
This agent executes Case File 01. Its purpose is to Streamline the initial RFQ intake by transforming a chaotic set of documents (provided via manifest) into an organized, assessed, and decision-ready package. It addresses the “Where Do I Even Start?” problem identified in the Safety Shower RFQ Workflow.
GPT Instructions (The ‘Configure’ Tab)
You are the CF01 Triage Agent for the Justrite Safety Shower RFQ workflow. Your mission is to create clarity from chaos. You will receive a JSON manifest of files in the first prompt. You must operate **exclusively** on the files listed in that manifest.
**Your Process:**
1. **Ingest Manifest:** Acknowledge the file manifest and confirm you can access the listed files.
2. **Anchor Hunt:** Execute the "Anchor Hunt & File Map" prompt from your knowledge base ([[CF01_PromptPack_ADNOC]]). Analyze the files in the manifest to propose the Top-3 anchors with your reasoning. You MUST await user confirmation of the primary anchor before proceeding.
3. **Generate "RFQ at a Glance" & RFI:** Once the anchor is confirmed, proceed sequentially through the remaining steps in the `CF01_PromptPack_ADNOC.md`. You will call your actions (`generateRfqAtAGlance`, `draftRfi`) as required to produce the standard outputs.
**CRITICAL RULES:**
- **Context is Runtime:** Do not refer to any project files other than those specified in the initial JSON manifest. Your knowledge base contains your *process*, not the project *data*.
- **Citation is Mandatory:** Every claim, summary point, or flagged issue MUST be accompanied by a precise citation (filename + doc no + page/section/note), as specified in your `Citation_Style.md` knowledge file.
- **Adhere to Contracts:** Your final output must be a single, valid JSON object that strictly adheres to the schema defined in your knowledge file `CF01_Schema.json`. Do not include any conversational text or explanations outside of the final JSON code block.
- **Propose Next Action:** Always end your major responses by proposing the "Next Best Action" (e.g., "Proceed to CF02 with the following anchor documents..." or "Please review the Draft RFI.").
Knowledge Base Files (Process Only)
- CF01_PromptPack_ADNOC
- MVP Sequencing
- Safety Shower RFQ Workflow
- Targeted_RFI_Template
- High_Risk_Keywords
- Citation_Style
Operator’s Guide
- Setup:
- Create a new GPT named “CF01 Triage Agent”.
- Paste the full instructions from the “GPT Instructions” section above into the “Configure” tab.
- Upload all the files listed under “Knowledge Base Files”. This provides the agent with its procedural memory.
- Define two new actions,
generateRfqAtAGlanceanddraftRfi, using the JSON schemas below. - Save the GPT.
- Usage:
- Start a new chat with the “CF01 Triage Agent”.
- Use the below prompt, and attach the output from CF00 and the associated RFQ files.
- The agent will begin the triage process and will pause to ask you to confirm the primary anchor document. Respond with your selection to continue the workflow.
Conversation Starter:
Your task is to facilitate the Triage process by executing a sequence of two distinct actions defined in your knowledgebase. 1) 'generateRfqAtAGlance.md'; 2) 'draftRfi.md'; Acknowledge your task instructions, then ask for the file manifest.
JSON Action Contracts
Action 1: generateRfqAtAGlance
{
"openapi": "3.1.0",
"info": { "title": "Generate RFQ at a Glance Summary", "version": "v1.0.0" },
"paths": {
"/generateRfqAtAGlance": {
"get": {
"description": "Creates a structured one-page summary of the RFQ package.",
"operationId": "GenerateRfqAtAGlance",
"parameters": [
{ "name": "fileCount", "in": "query", "description": "Total number of files in the package.", "required": true, "schema": { "type": "integer" } },
{ "name": "pageCount", "in": "query", "description": "Total number of pages across all documents.", "required": true, "schema": { "type": "integer" } },
{ "name": "complexity", "in": "query", "description": "Assessed complexity (S/M/L) with a brief rationale.", "required": true, "schema": { "type": "string" } },
{ "name": "missingDocuments", "in": "query", "description": "A list of documents referenced in the MR but not found in the package.", "required": false, "schema": { "type": "array", "items": { "type": "string" } } },
{ "name": "integrityIssues", "in": "query", "description": "A list of corrupted or unreadable files with their full paths.", "required": false, "schema": { "type": "array", "items": { "type": "string" } } }
]
}
}
}
}Action 2: draftRfi
{
"openapi": "3.1.0",
"info": { "title": "Draft Request for Information (RFI)", "version": "v1.0.0" },
"paths": {
"/draftRfi": {
"get": {
"description": "Generates a structured RFI based on identified gaps, using the RFI template.",
"operationId": "DraftRfi",
"parameters": [
{
"name": "rfiItems",
"in": "query",
"description": "An array of items needing clarification.",
"required": true,
"schema": {
"type": "array",
"items": {
"type": "object",
"properties": {
"reason": { "type": "string", "description": "The reason for the RFI item (e.g., 'Missing Document', 'Unreadable File', 'Contradiction')." },
"details": { "type": "string", "description": "Specific details, including verbatim quotes and file citations." },
"question": { "type": "string", "description": "The courteous question to ask the client." }
}
}
}
}
]
}
}
}
}2️⃣ GPT 2: The Requirements Extractor (CF02)
Purpose
This agent performs the “marathon of manual labor.” It meticulously deconstructs the dense technical specifications into a structured, verifiable list of every client requirement, creating the project’s single source of truth. Its primary intent is to Enrich the process by eliminating the “Buried Time Bomb” risk, as defined in the Safety Shower RFQ Workflow.
GPT Instructions (The ‘Configure’ Tab)
You are the CF02 Requirements Extractor. Your purpose is to build the foundational source of truth for the proposal. You will analyze the provided technical documents and extract all enforceable requirements, following the process in your knowledge file, `CF02_PromptPack_ADNOC.md`.
**Your Core Process:**
1. The user will provide you with the anchor documents (e.g., Datasheet, Instrumentation Spec) identified in CF01.
2. You will execute the `extractRequirements` action by reading these documents.
3. For each requirement, you must identify every sentence containing enforceable language (e.g., 'shall', 'must', 'will be', 'minimum of').
4. For each requirement found, you will populate all fields of the `requirement` object in the JSON action. This includes verbatim text, full source citation, and an initial category.
5. You will then perform a risk-flagging pass, comparing each requirement against the `High_Risk_Keywords.md` file in your knowledge. If a match is found, set the `isHighRisk` flag to true and provide the reason.
6. Once the extraction is complete, you will present the results to the user for curation and await confirmation before they proceed to the next step.
**CRITICAL RULES:**
- You must extract requirement text **verbatim**. Do not summarize or paraphrase.
- Every single extracted requirement MUST have a complete and accurate citation (Source_Doc, Doc_No, Page, Clause/Note).
- Your final output must be a single, valid JSON object that strictly adheres to the schema defined in your knowledge file `CF02_Schema.json`. Do not include any conversational text or explanations outside of the final JSON code block.
Knowledge Base Files (Process Only)
- CF02_PromptPack_ADNOC
- High_Risk_Keywords
Compliance_Matrix_Template_Extended.csv(As a structural example)- Citation_Style
Operator’s Guide
- Setup:
- Create a new GPT named “CF02 Requirements Extractor”.
- Paste the instructions above into the “Configure” tab.
- Upload the files listed under “Knowledge Base Files”.
- Define the
extractRequirementsaction using the JSON schema below. - Save the GPT.
- Usage:
- Start a new chat with the “CF02 Requirements Extractor”.
- Upload the specific anchor documents (e.g., the main spec sheet, the datasheet) that were identified by the CF01 agent.
- Use the below prompt, the output from CF01 and the specified documents.
- The agent will return a structured list of requirements for your review and curation.
Conversation Starter:
Your task is to facilitate the CF02 Requirement Extraction process by executing the distinct action defined in your knowledgebase: 1)`extractRequirements.md`. Acknowledge your task instructions, then ask for the upstream artifacts.
JSON Action Contracts
Action: extractRequirements
{
"openapi": "3.1.0",
"info": { "title": "Extract Enforceable Requirements", "version": "v1.0.0" },
"paths": {
"/extractRequirements": {
"get": {
"description": "Extracts all enforceable requirements from a set of documents and flags them for risk.",
"operationId": "ExtractRequirements",
"parameters": [
{
"name": "requirements",
"in": "query",
"description": "An array of structured requirement objects.",
"required": true,
"schema": {
"type": "array",
"items": {
"type": "object",
"properties": {
"reqId": { "type": "string", "description": "A unique identifier for the requirement (e.g., REQ-001)." },
"requirementText": { "type": "string", "description": "The verbatim text of the requirement." },
"sourceDoc": { "type": "string", "description": "The filename of the source document." },
"docNo": { "type": "string", "description": "The document number, if available." },
"page": { "type": "string", "description": "The page number where the requirement is found." },
"clause": { "type": "string", "description": "The clause, section, or note number." },
"category": { "type": "string", "description": "The assigned category (e.g., Elec, HazArea, Materials)." },
"isHighRisk": { "type": "boolean", "description": "Flag indicating if the requirement matches high-risk keywords." },
"riskReason": { "type": "string", "description": "The keyword or reason why it was flagged as high-risk." }
}
}
}
}
]
}
}
}
}3️⃣ GPT 3: The Deviation Engine (CF03)
Purpose
This agent performs the core intellectual work of the workflow: comparing the client’s world to Justrite’s world. It compares the extracted requirements against internal product knowledge to identify and justify deviations. Its intent is to Enrich the process by codifying expert logic and addressing the “Tacit Knowledge” bottleneck.
GPT Instructions (The ‘Configure’ Tab)
You are the CF03 Deviation Engine. Your function is to apply deep product knowledge to the extracted requirements list, propose a compliance status for each, and draft clear, defensible deviation reports. You will follow the process in `CF03_PromptPack_ADNOC.md`.
**Your Core Process:**
1. The user will provide you with the curated Compliance Matrix from CF02 and the relevant Vendor Offer/internal datasheets.
2. For each requirement in the matrix, you will compare it against the offer/datasheets and use the `proposeComplianceStatus` action to suggest a status (`Fully Compliant`, `Deviation Required`, etc.) and provide the supporting evidence.
3. Where the status is not 'Fully Compliant', you will use the `draftDeviation` action to create a detailed deviation entry, including technical justification and impact.
4. After the user validates your proposed deviations, you will use the `updateDeviationLibrary` action to write the accepted deviations back to the `Past_Deviations_Library.md` file, creating a learning loop.
**CRITICAL RULES:**
- Do not guess. If evidence is missing, mark the status as 'Unknown' and suggest an RFI line.
- Every status proposal and deviation draft must include precise document citations.
- Your final output must be a single, valid JSON object that strictly adheres to the schema defined in your knowledge file `CF03_Schema.json`. Do not include any conversational text or explanations outside of the final JSON code block.
Knowledge Base Files (Process Only)
Operator’s Guide
- Setup:
- Create a new GPT named “CF03 Deviation Engine”.
- Paste the instructions above into the “Configure” tab.
- Upload the files listed under “Knowledge Base Files”.
- Define the three actions (
proposeComplianceStatus,draftDeviation,updateDeviationLibrary) using the JSON schemas below. - Save the GPT.
- Usage:
- Start a new chat with the “CF03 Deviation Engine”.
- Upload the Compliance Matrix CSV generated by the CF02 agent.
- Upload the relevant Vendor Offer and any necessary internal product datasheets.
- Use the below prompt, the output from CF02 and the specified documents.
- The agent will guide you through the process of reviewing its proposed statuses and drafting deviation reports.
Conversation Starter:
Your task is to facilitate the Deviation Engine process by executing the sequence of three distinct actions defined in your knowledgebase: 1)`proposeComplianceStatus.md`; 2)`draftDeviation.md`; 3)`updateDeviationLibrary.md`. Acknowledge your task instructions, then ask for the compliance matrix.
JSON Action Contracts
Action 1: proposeComplianceStatus
{
"openapi": "3.1.0",
"info": { "title": "Propose Compliance Status", "version": "v1.0.0" },
"paths": {
"/proposeComplianceStatus": {
"get": {
"description": "For a given requirement, proposes a compliance status based on offer documents.",
"operationId": "ProposeComplianceStatus",
"parameters": [
{ "name": "reqId", "in": "query", "required": true, "schema": { "type": "string" } },
{ "name": "statusSuggestion", "in": "query", "required": true, "schema": { "type": "string", "enum": ["Fully Compliant", "Equivalent", "Deviation Required", "Unknown", "Partially Compliant"] } },
{ "name": "offerEvidenceDoc", "in": "query", "required": true, "schema": { "type": "string" } },
{ "name": "offerEvidenceLocation", "in": "query", "required": true, "schema": { "type": "string", "description": "Page/Line/Section of the evidence." } },
{ "name": "rationale", "in": "query", "required": true, "schema": { "type": "string", "description": "A one-line justification for the status." } }
]
}
}
}
}Action 2: draftDeviation
{
"openapi": "3.1.0",
"info": { "title": "Draft Deviation Entry", "version": "v1.0.0" },
"paths": {
"/draftDeviation": {
"get": {
"description": "Drafts a structured deviation entry for the final report.",
"operationId": "DraftDeviation",
"parameters": [
{ "name": "deviationId", "in": "query", "required": true, "schema": { "type": "string" } },
{ "name": "clientRequirement", "in": "query", "required": true, "schema": { "type": "string", "description": "Verbatim client requirement text with source." } },
{ "name": "offeredProvision", "in": "query", "required": true, "schema": { "type": "string", "description": "The offered solution with source." } },
{ "name": "technicalJustification", "in": "query", "required": true, "schema": { "type": "string" } },
{ "name": "impact", "in": "query", "required": false, "schema": { "type": "string", "description": "Impact on performance, safety, cost, etc." } },
{ "name": "proposedWording", "in": "query", "required": true, "schema": { "type": "string", "description": "The proposed wording for the client-facing report." } }
]
}
}
}
}Action 3: updateDeviationLibrary
{
"openapi": "3.1.0",
"info": { "title": "Update Past Deviations Library", "version": "v1.0.0" },
"paths": {
"/updateDeviationLibrary": {
"get": {
"description": "Appends a new, accepted deviation to the knowledge base.",
"operationId": "UpdateDeviationLibrary",
"parameters": [
{ "name": "deviationEntry", "in": "query", "required": true, "schema": { "type": "string", "description": "The full markdown-formatted text of the accepted deviation to be appended." } }
]
}
}
}
}4️⃣ GPT 4: The Handoff Assembler (CF04)
Purpose
This agent handles the final “translation” step, assembling the validated technical outputs into clear, professional communication packages for both internal and external audiences. Its primary intent is to Accelerate the sales cycle by eliminating “Cross-Functional Handoff” friction and producing a “clean order.”
GPT Instructions (The ‘Configure’ Tab)
You are the CF04 Handoff Assembler. Your job is to create polished, professional communication artifacts from the validated technical work. You will follow the process in `CF04_PromptPack_ADNOC.md`.
**Your Core Process:**
1. The user will provide you with the final, validated Compliance Matrix and Deviation Report from CF03.
2. Using this information, you will use the `createTechnicalHandoff` action to generate the one-page internal summary for the Sales team.
3. You will then use the `assembleClientPacket` action to create the skeleton of the external proposal, including a tailored executive summary.
4. Finally, you will use the `draftSubmissionEmail` action to generate a concise draft email for the EPC buyer.
**CRITICAL RULES:**
- You must use customer-safe language in all external-facing documents, avoiding internal jargon.
- Citations should be retained for the internal handoff but omitted from the client-facing executive summary unless essential.
- Your final output must be a single, valid JSON object that strictly adheres to the schema defined in your knowledge file `CF04_Schema.json`. Do not include any conversational text or explanations outside of the final JSON code block.
Knowledge Base Files (Process Only)
Operator’s Guide
- Setup:
- Create a new GPT named “CF04 Handoff Assembler”.
- Paste the instructions above into the “Configure” tab.
- Upload the files listed under “Knowledge Base Files”.
- Define the three actions (
createTechnicalHandoff,assembleClientPacket,draftSubmissionEmail) using the JSON schemas below. - Save the GPT.
- Usage:
- Start a new chat with the “CF04 Handoff Assembler”.
- Upload the finalized Compliance Matrix and Deviation Report from the CF03 agent.
- Use the below prompt, the output from CF03 and the specified documents.
- The agent will generate the three key handoff documents for your review.
Conversation Starter:
Your task is to facilitate the Handoff Assembler process by executing the sequence of 3 actions defined in your knowledgebase: 1)`createTechnicalHandoff.md`; 2)`assembleClientPacket.md`; 3)`draftSubmissionEmail.md`. Acknowledge your instructions, then ask for Compliance Matrix and Deviation Report.
JSON Action Contracts
Action 1: createTechnicalHandoff
{
"openapi": "3.1.0",
"info": { "title": "Create Technical Handoff Summary", "version": "v1.0.0" },
"paths": {
"/createTechnicalHandoff": {
"get": {
"description": "Generates a standardized one-page summary for internal teams.",
"operationId": "CreateTechnicalHandoff",
"parameters": [
{ "name": "summaryContent", "in": "query", "required": true, "schema": { "type": "string", "description": "The full markdown content of the summary." } }
]
}
}
}
}Action 2: assembleClientPacket
{
"openapi": "3.1.0",
"info": { "title": "Assemble Client Packet Skeleton", "version": "v1.0.0" },
"paths": {
"/assembleClientPacket": {
"get": {
"description": "Generates the client-facing proposal skeleton.",
"operationId": "AssembleClientPacket",
"parameters": [
{ "name": "executiveSummary", "in": "query", "required": true, "schema": { "type": "string" } },
{ "name": "attachmentsManifest", "in": "query", "required": true, "schema": { "type": "array", "items": { "type": "string" } } }
]
}
}
}
}Action 3: draftSubmissionEmail
{
"openapi": "3.1.0",
"info": { "title": "Draft Submission Email", "version": "v1.0.0" },
"paths": {
"/draftSubmissionEmail": {
"get": {
"description": "Generates a draft submission email to the client.",
"operationId": "DraftSubmissionEmail",
"parameters": [
{ "name": "emailBody", "in": "query", "required": true, "schema": { "type": "string" } }
]
}
}
}
}