Implementation Guide: Transcribe Program Reviews, TIMs & Inter-Agency Coordination Calls — Generate Structured Action Item Logs

Software Procurement

Microsoft Teams GCC High — Transcription & Recording

Teams GCC High provides native meeting recording and transcription within the FedRAMP High authorization boundary. Transcripts are stored in OneDrive for Business (GCC High), which meets DFARS 252.204-7012 cloud storage requirements. AI-generated meeting summaries and action items via Microsoft Copilot for M365 Government are available with E5 licensing or Copilot add-on ($30/user/month).

Microsoft Azure AI Speech (GCC High / IL4)

Otter.ai for Government (Unclassified / Low CUI only)

Granola (Meeting Notes AI — Unclassified)

Hardware Procurement

Prerequisites

• Facility security clearance (if applicable): If any meetings to be captured occur in a Sensitive Compartmented Information Facility (SCIF) or a closed area, electronic recording devices are strictly prohibited. Confirm with the client's Facility Security Officer (FSO) that the target meeting environments are approved for electronic recording equipment before any deployment begins.
• CUI data classification determination: The client's Information System Security Officer (ISSO) or Data Owner must formally classify the sensitivity of meeting content before selecting a platform. Unclassified → Otter.ai or Granola acceptable. CUI/DFARS → Azure Government + Teams GCC High required. ITAR-controlled → Azure Government IL4/IL5 required. Classified → no commercial solution; out of scope.
• Microsoft 365 GCC High tenant: If using Teams GCC High transcription, the client must have an active M365 GCC High tenant. Migration from commercial M365 or standard GCC to GCC High is a separate engagement (typically 4–8 weeks). Do not begin this deployment if the client is on commercial M365 and handling CUI.
• Azure Government subscription: Required for Azure AI Speech + Azure OpenAI pipeline. Must be provisioned under the client's or MSP's Azure Government enrollment. Standard Azure (azure.com) is not authorized for CUI.
• CMMC scoping document: Obtain the client's current CMMC System Security Plan (SSP) or scoping documentation. The AI transcription system must be added to the CMMC boundary if it processes, stores, or transmits CUI. Work with the client's ISSO to determine if an SSP update is required before go-live.
• Network infrastructure: Conference rooms must have wired Ethernet connections for AV hardware (Poly Studio, Neat Bar). Wi-Fi is acceptable for laptop-based capture but wired is preferred for reliability. All network connections must be on the organization's CMMC-scoped network — do not connect AV devices to guest or visitor networks.
• Government customer approval: For meetings with government customers (e.g., PMRs attended by a DoD Contracting Officer or Program Manager), the contractor must obtain explicit approval from the government customer before recording. Many government employees are prohibited by agency policy from consenting to recording of official government meetings by contractors. Obtain written approval and retain on file.
• IT administrator access: MSP technician requires Global Admin access to the M365 GCC High tenant, Owner access to the Azure Government subscription, and local admin access to all AV hardware for configuration.

Installation Steps

Step 1: Configure Microsoft Teams GCC High for Meeting Recording and Transcription

Enable meeting recording and transcription policies in the Teams GCC High admin center. Configure retention policies to store recordings and transcripts in SharePoint/OneDrive GCC High in compliance with DFARS 252.204-7012 cloud storage requirements.

Install-Module -Name MicrosoftTeams -Force -AllowClobber

Connect-MicrosoftTeams -TeamsEnvironmentName TeamsGCCH

New-CsTeamsMeetingPolicy -Identity "ProgramOfficePolicy" `
  -AllowCloudRecording $true `
  -AllowTranscription $true `
  -AllowRecordingStorageOutsideRegion $false `
  -RecordingStorageMode "OneDriveForBusiness" `
  -AutomaticallyStartCopilot Enabled

$users = Get-CsOnlineUser -Filter {Department -eq "Program Office"}
foreach ($user in $users) {
    Grant-CsTeamsMeetingPolicy -Identity $user.UserPrincipalName `
      -PolicyName "ProgramOfficePolicy"
}

Get-CsOnlineUser -Identity "pm.user@agency.gov" | Select-Object TeamsModernMeetingPolicy

Step 2: Deploy Azure Government Resources for Custom Transcription Pipeline

Provision Azure AI Speech and Azure OpenAI resources in Azure Government for organizations requiring a custom pipeline (e.g., processing audio from non-Teams sources such as physical room recorders or legacy telephony).

az cloud set --name AzureUSGovernment
az login

az group create \
  --name rg-transcription-prod \
  --location usgovvirginia \
  --subscription "<AZURE_GOV_SUBSCRIPTION_ID>"

az cognitiveservices account create \
  --name speech-transcription-prod \
  --resource-group rg-transcription-prod \
  --kind SpeechServices \
  --sku S0 \
  --location usgovvirginia \
  --yes

az cognitiveservices account keys list \
  --name speech-transcription-prod \
  --resource-group rg-transcription-prod

az cognitiveservices account create \
  --name openai-actionitems-prod \
  --resource-group rg-transcription-prod \
  --kind OpenAI \
  --sku S0 \
  --location usgovvirginia \
  --yes

az cognitiveservices account deployment create \
  --name openai-actionitems-prod \
  --resource-group rg-transcription-prod \
  --deployment-name gpt4o-deployment \
  --model-name gpt-5.4 \
  --model-version "2024-08-06" \
  --model-format OpenAI \
  --capacity 10

az storage account create \
  --name stgtranscriptionprod \
  --resource-group rg-transcription-prod \
  --location usgovvirginia \
  --sku Standard_ZRS \
  --kind StorageV2 \
  --min-tls-version TLS1_2 \
  --allow-blob-public-access false \
  --https-only true

Step 3: Build the Audio-to-Action-Item Pipeline (Azure Functions)

Deploy an Azure Function App that automates the end-to-end pipeline: receive an audio file upload → transcribe via Azure AI Speech → generate action item log via Azure OpenAI → output a structured Markdown/JSON document → store in SharePoint GCC High.

# Azure Function: transcribe_and_summarize/function_app.py
# Deploy to Azure Functions (Consumption plan, USGov Virginia)

import azure.functions as func
import logging
import os
import json
from azure.cognitiveservices.speech import SpeechConfig, AudioConfig, SpeechRecognizer
from azure.cognitiveservices.speech.audio import AudioStreamFormat, PushAudioInputStream
from openai import AzureOpenAI

app = func.FunctionApp()

SPEECH_KEY = os.environ["AZURE_SPEECH_KEY"]
SPEECH_REGION = os.environ["AZURE_SPEECH_REGION"]  # e.g., "usgovvirginia"
OPENAI_ENDPOINT = os.environ["AZURE_OPENAI_ENDPOINT"]
OPENAI_KEY = os.environ["AZURE_OPENAI_KEY"]
OPENAI_DEPLOYMENT = os.environ["AZURE_OPENAI_DEPLOYMENT"]  # "gpt4o-deployment"

ACTION_ITEM_PROMPT = """
You are a program management assistant supporting a defense contractor. 
You have been given a meeting transcript from a program review or technical interchange meeting.

Extract and structure the following from the transcript:

1. MEETING METADATA
   - Meeting type (PMR / TIM / IPT / Coordination Call / Other)
   - Date and time (if mentioned)
   - Attendees (by name and organization if identifiable)
   - Classification level (UNCLASSIFIED / CUI — state what is indicated in the transcript)

2. ACTION ITEMS
   For each action item identified, provide:
   - Action item number (sequential)
   - Description (clear, specific, actionable)
   - Owner (person responsible)
   - Due date (if mentioned; otherwise note 'TBD')
   - Priority (High / Medium / Low based on context)
   - Source (brief quote or context from transcript)

3. KEY DECISIONS
   List any formal decisions made during the meeting.

4. OPEN ISSUES / RISKS
   List any unresolved issues or risks raised that are not captured as action items.

5. NEXT MEETING
   Date, time, and agenda items for the next meeting (if discussed).

Format output as structured Markdown suitable for entry into a program management system.
Flag any content that may be CUI with [CUI] tag for reviewer attention.

TRANSCRIPT:
{transcript}
"""

@app.blob_trigger(arg_name="audioblob",
                  path="incoming-audio/{name}",
                  connection="AzureWebJobsStorage")
def process_meeting_audio(audioblob: func.InputStream):
    logging.info(f"Processing audio file: {audioblob.name}")
    audio_data = audioblob.read()

    # Transcribe using Azure AI Speech (batch transcription for files > 1 min)
    speech_config = SpeechConfig(subscription=SPEECH_KEY, region=SPEECH_REGION)
    speech_config.speech_recognition_language = "en-US"
    speech_config.request_word_level_timestamps()
    speech_config.enable_dictation()

    # Speaker diarization (up to 10 speakers for standard meetings)
    speech_config.set_property_by_name(
        "SpeechServiceConnection_SingleLanguageIdPriority", "Latency"
    )

    # For production: use Batch Transcription API for files > 15 minutes
    # See: https://learn.microsoft.com/azure/ai-services/speech-service/batch-transcription
    transcript_text = "[Transcript from Azure Speech batch job]"  # Replace with actual batch call

    # Generate action item log via Azure OpenAI
    client = AzureOpenAI(
        azure_endpoint=OPENAI_ENDPOINT,
        api_key=OPENAI_KEY,
        api_version="2024-08-01-preview"
    )

    response = client.chat.completions.create(
        model=OPENAI_DEPLOYMENT,
        messages=[
            {"role": "system", "content": "You are a defense program management assistant. Handle all content as CUI unless explicitly marked otherwise."},
            {"role": "user", "content": ACTION_ITEM_PROMPT.format(transcript=transcript_text)}
        ],
        temperature=0.1,  # Low temperature for factual extraction
        max_tokens=4000
    )

    action_item_log = response.choices[0].message.content
    logging.info("Action item log generated successfully.")

    # Output to storage (SharePoint upload handled separately via Graph API)
    return action_item_log

Step 4: Configure Physical Conference Room AV Hardware

Install and configure Poly Studio X70 or Neat Bar Pro in program review conference rooms. Register devices to the Teams GCC High tenant. Configure rooms as Microsoft Teams Rooms (MTR) resource accounts. ``powershell # Create Teams Room resource account in M365 GCC High # Run in Exchange Online PowerShell (GCC High) Connect-ExchangeOnline -ExchangeEnvironmentName O365USGovGCCHigh New-Mailbox -Name "Program Review Room A" -Alias "room-review-a" -Room -EnableRoomMailboxAccount $true ...

Step 5: Deploy Otter.ai for Government (Unclassified Environments)

For clients not handling CUI — civilian agency unclassified programs, grant-funded research organizations, or unclassified contractor coordination — deploy Otter.ai Business or Enterprise as the simpler, lower-cost alternative.

# Azure AD SAML Attribute Mappings for Otter.ai SSO
User.mail → NameID
User.displayName → display_name
User.department → department

Step 6: Configure CUI Handling Labels in SharePoint GCC High

Apply Microsoft Purview sensitivity labels to all transcript and action item documents stored in SharePoint GCC High to enforce CUI handling requirements per NIST SP 800-171 and the CUI Registry.

# Connect to Microsoft Purview Compliance (GCC High)
Connect-IPPSSession -Environment USGovGCCHigh

# Create sensitivity label for CUI - Program Information
New-Label -Name "CUI-ProgramInfo" `
  -DisplayName "CUI // Program Information" `
  -Tooltip "Apply to documents containing CUI related to government programs" `
  -ContentType File,Email

# Configure label settings (encryption + marking)
Set-Label -Identity "CUI-ProgramInfo" `
  -EncryptionEnabled $true `
  -EncryptionProtectionType Template `
  -EncryptionRightsDefinitions "agency.onmicrosoft.us:VIEW,VIEWRIGHTSDATA,EDIT,PRINT,EXTRACT,REPLY,REPLYALL,FORWARD,OBJMODEL" `
  -HeaderText "CUI // PROGRAM INFORMATION" `
  -HeaderFontSize 11 `
  -HeaderFontColor "#FF0000" `
  -FooterText "CONTROLLED UNCLASSIFIED INFORMATION" `
  -FooterFontSize 10 `
  -FooterFontColor "#FF0000"

# Create auto-labeling policy to automatically label transcripts
New-AutoSensitivityLabelPolicy -Name "AutoLabel-MeetingTranscripts" `
  -Labels "CUI-ProgramInfo" `
  -Locations "SharePoint","OneDriveForBusiness" `
  -Mode Enable

New-AutoSensitivityLabelRule -Policy "AutoLabel-MeetingTranscripts" `
  -Name "TranscriptKeywords" `
  -ContentContainsSensitiveInformation @{name="U.S. Defense Contract Number"; mincount="1"} `
  -Workload SharePoint,OneDrive

# Verify label policy is published
Get-LabelPolicy | Where-Object {$_.Name -like "*Transcript*"} | Select Name,Labels,Locations

Custom AI Components

Action Item Register Auto-Population Prompt

Type: Prompt A structured system prompt for the Azure OpenAI pipeline that extracts action items from meeting transcripts and formats them for import into common program management tools (Microsoft Project, Jira, or the contractor's Integrated Master Schedule system).

Implementation:

# System Message for Azure OpenAI

## Action Item Register Extraction Prompt

SYSTEM PROMPT (configure as system message in Azure OpenAI call):

You are a defense program management assistant operating in a CUI environment.
Extract all action items from the following meeting transcript and format them
as a structured action item register suitable for import into a program management system.

For each action item, extract:
- AI# (sequential number, e.g. AI-001)
- Date Assigned (from transcript date or 'TBD')
- Description (specific, measurable, actionable — rewrite vague statements as clear tasks)
- Owner (Last Name, First Name if identifiable; otherwise role/organization)
- Organization (owner's organization/company)
- Due Date (exact date if stated; '+ X days' if relative; 'TBD' if not mentioned)
- Priority (Critical / High / Medium / Low — assess from discussion context and urgency language)
- Status (Open — all new items are Open)
- Source Quote (verbatim quote from transcript that generated this action, max 50 words)
- Notes (any caveats, dependencies, or conditions mentioned)

OUTPUT FORMAT: JSON array of action item objects. Example:
[
  {
    "ai_number": "AI-001",
    "date_assigned": "2025-01-15",
    "description": "Provide updated IMS baseline reflecting revised CDR date to PM office",
    "owner": "Smith, John",
    "organization": "Contractor XYZ",
    "due_date": "2025-01-22",
    "priority": "High",
    "status": "Open",
    "source_quote": "John said he'd get us the updated IMS by next Wednesday at the latest",
    "notes": "Must include CDR date change impact on downstream milestones"
  }
]

RULES:
- Only extract genuine action items (commitments to do something by someone)
- Do not fabricate owners or due dates not mentioned in the transcript
- Flag ambiguous action items with a [NEEDS CLARIFICATION] note
- Mark any content containing contract numbers, program names, or technical specs with [CUI-REVIEW]
- If no action items are identified, return an empty array with a note explaining why

TRANSCRIPT:
{transcript_text}

Teams Meeting Auto-Summary Power Automate Flow

Type: Integration

A Power Automate (GCC High) flow that triggers when a Teams GCC High meeting recording is completed, automatically initiates the transcription pipeline, and posts the structured action item log to the program's SharePoint site and sends a summary email to all attendees.

Implementation

Flow Trigger

• Trigger: When a file is created in OneDrive for Business (GCC High)
• Folder: /Recordings (Teams auto-saves recordings here)
• File type filter: *.mp4

Step 1: Get File Metadata

• Action: Get file properties
• Extract: filename, created date, file URL, meeting organizer

Step 2: Parse Meeting Name from Filename

Teams recording filenames follow: "Meeting Name-YYYYMMDD_HHMMSS-Meeting Recording.mp4". Use a 'Compose' action with the following expression:

split(triggerBody()?['Name'], '-')[0]

Step 3: Check if Transcript Already Exists

• Action: Get file (OneDrive)
• Path: /Transcripts/[meeting-name]-transcript.vtt
• Configure 'Run after': Set to run even if previous step fails
• If transcript exists: use Teams-native transcript (skip Azure Speech)
• If no transcript: trigger Azure Function via HTTP POST

Step 4: HTTP POST to Azure Function (if no native transcript)

POST https://[function-app].azurewebsites.us/api/process_meeting_audio
x-functions-key: [function-key]
Content-Type: application/json

{
  "audio_url": "[OneDrive file URL]",
  "meeting_name": "[parsed name]"
}

Step 5: Create Action Item Document in SharePoint (GCC High)

• Action: Create file (SharePoint GCC High — sharepoint.us domain)
• Site: https://[tenant].sharepoint.us/sites/ProgramOffice
• Folder: /Action Item Registers/[Year]/[Month]
• Filename: [meeting-name]-AI-Register-[date].md
• Content: [output from Azure Function / Copilot]
• Apply sensitivity label: CUI-ProgramInfo (via Purview API call)

Step 6: Send Email Summary to Attendees

• Action: Send email (Office 365 GCC High)
• To: [meeting attendees from calendar event]
• Subject: Action Items — [Meeting Name] — [Date]
• Body: HTML-formatted action item table (top 10 items, link to full register)
• Attachment: Full action item register document

Step 7: Create Tasks in Microsoft Planner (GCC High)

For each action item with an identified owner, create a Planner task with the following fields:

• Action: Create task (Planner)
• Plan: Program Office Action Items
• Title: [AI#] — [Description]
• Assigned to: [Owner UPN]
• Due date: [Due Date]
• Notes: [Source Quote + Notes]

Governance

• Flow runs as a Service Account (not personal user account)
• Service Account — OneDrive permission: Read (source recordings folder only)
• Service Account — SharePoint permission: Read/Write (program site action items library only)
• Service Account — Planner permission: Read/Write (program plan only)
• Service Account — Exchange permission: Send As (service account mailbox)
• Log all flow runs to Azure Monitor Log Analytics (GCC High) for audit trail

Testing & Validation

- Audio capture quality test: Record a 10-minute simulated program review meeting with 4–6 speakers in the target conference room. Upload to the transcription pipeline and verify: (a) all speakers are captured clearly, (b) speaker diarization correctly distinguishes between speakers, (c) transcript word error rate is below 10% for standard American English speech. - CUI boundary test: Confirm that no audio data or transcript content is transmitted to commercial cloud endpoints. Use Wires...

Client Handoff

...

Client Handoff Meeting Agenda (60 minutes — Program Manager + ISSO + IT Lead)

1. Architecture Review (10 min) - Review data flow: microphone → Teams GCC High / Azure Government → SharePoint GCC High → Planner - Confirm all data remains within the authorized boundary (no commercial cloud touchpoints for CUI) - Present network diagram showing AV device VLAN, firewall rules, and authorized egress points 2. Compliance Documentation (15 min) - Present updated CMMC SSP section covering the AI transcription system - Review CUI sensitivity label configuration and auto-la...

Maintenance

Monthly Tasks

• Review Azure Government cost dashboard — monitor Azure AI Speech and Azure OpenAI consumption costs. Alert client if monthly consumption exceeds budget thresholds.
• Verify Power Automate flow run history — check for failed runs and investigate any errors in the processing pipeline.
• Review SharePoint storage utilization for the recordings and transcript libraries. Confirm retention policies are executing deletions on schedule.
• Check Teams GCC High admin center for any policy changes or license compliance issues.

Quarterly Tasks

Annual Tasks

• CMMC assessment preparation: Ensure all evidence of the AI transcription controls (audit logs, SSP, data flow diagrams, CUI label reports) is current and accessible for the annual CMMC assessment or surveillance review.
• Azure resource right-sizing: Review Azure AI Speech and OpenAI consumption patterns. Adjust capacity commitments to optimize cost.
• Records schedule review: Confirm the data retention period for meeting transcripts and action item registers still aligns with the client's agency records schedule and any applicable contract records requirements.

Alternatives

Veritone Government (FedRAMP High Authorized Transcription)

AWS GovCloud — Amazon Transcribe + Bedrock

Amazon Transcribe (AWS GovCloud) provides FedRAMP High-authorized speech-to-text with speaker diarization, and Amazon Bedrock (GovCloud) provides access to Claude and other LLMs within the FedRAMP High boundary. Architecturally equivalent to the Azure Government pipeline described above but on AWS infrastructure. Best for: Organizations already standardized on AWS GovCloud. Tradeoffs: Requires AWS GovCloud account provisioned through proper government contracting channels; less native integration with Microsoft 365 GCC High than the Azure approach.

On-Premises / Air-Gapped Solution (Classified-Adjacent Environments)