Implementation Guide: Draft ndas, service agreements, and standard contracts from firm templates

Hardware Procurement

Software Procurement

Prerequisites

• Active Microsoft 365 Business Premium (or higher) tenant with all user licenses assigned and Azure AD/Entra ID configured. Verify tenant is on current release channel for Microsoft 365 Apps.
• Microsoft Word desktop application (not web-only) installed on all attorney and paralegal workstations — version 2301 or later from Microsoft 365 Apps. Required for Spellbook Word add-in.
• Microsoft Intune enrollment for all managed devices (included in M365 Business Premium). Required for centralized deployment of Word add-ins and security policies.
• Azure AD/Entra ID Conditional Access policies configured: MFA enforced for all users, block sign-in from unmanaged devices, require compliant devices for access to SharePoint/OneDrive.
• Reliable internet connectivity: minimum 100 Mbps symmetric (fiber strongly preferred). All AI processing occurs in the cloud; poor connectivity directly degrades drafting experience.
• Firewall configured to allow outbound HTTPS (port 443) to: *.spellbook.legal, *.clio.com, *.docusign.com, *.gavel.io, *.office.com, *.microsoft.com, *.microsoftonline.com, login.microsoftonline.com, graph.microsoft.com.
• Existing firm contract templates collected and inventoried in editable Microsoft Word (.docx) format. All templates must be in Word — no PDFs or paper-only templates (scan and OCR first if necessary).
• Practice management system active with current client and matter data (Clio Manage preferred; alternatives: Smokeball, PracticePanther, MyCase). Client intake fields must include: party names, addresses, effective dates, governing law, and deal-specific terms.
• Written approval from firm's managing partner or ethics committee to deploy AI-assisted contract drafting, acknowledging ABA Formal Opinion 512 obligations. Document this approval with date and signatory.
• Designated firm 'AI Champion' identified — typically a tech-savvy senior associate or partner who will serve as the primary liaison during implementation and internal advocate post-deployment.
• Domain DNS records properly configured for SPF, DKIM, and DMARC (email security) to ensure contract delivery emails are not flagged as spam.
• SharePoint Online or OneDrive for Business configured as the firm's document management system, with a clear folder structure: /Clients/{ClientName}/Matters/{MatterName}/Contracts/. If using NetDocuments or iManage, ensure API access is available.

Installation Steps

...

Step 1: Environment Audit and Baseline Assessment

Before any deployment, conduct a thorough audit of the firm's current technology environment, contract workflows, and template inventory. This establishes the baseline for the implementation and identifies any prerequisites that need remediation. Meet with the managing partner, a senior associate, and the office manager to document: (1) the top 10 most frequently drafted contract types by volume, (2) the current template library location and format, (3) existing practice management and DMS systems, (4) current contract turnaround times, (5) any compliance or jurisdictional requirements specific to the firm's practice areas.

# Connect to Microsoft 365 tenant and audit current licensing
Connect-MgGraph -Scopes 'User.Read.All','Organization.Read.All','Directory.Read.All'
Get-MgSubscribedSku | Select-Object SkuPartNumber, ConsumedUnits, PrepaidUnits | Format-Table
# List all users and their assigned licenses
Get-MgUser -All | Select-Object DisplayName, UserPrincipalName, AssignedLicenses | Export-Csv -Path 'C:\MSP\AuditOutput\M365UserLicenses.csv' -NoTypeInformation

• Navigate to: Intune Admin Center > Devices > All Devices > [Device] > Discovered Apps
• Verify Microsoft 365 Apps version is 2301 or later

Step 2: Microsoft 365 Environment Hardening

Ensure the Microsoft 365 tenant meets security requirements for handling confidential client data with AI tools. This includes enforcing MFA, configuring Conditional Access, deploying Intune compliance policies, and establishing the SharePoint document structure for contract storage. These security controls are mandatory under ABA Rule 1.6 (Confidentiality) and are prerequisites for passing any vendor security assessment.

• Navigate to: Entra ID > Protect & Secure > Conditional Access > New Policy
• Policy Name: 'Require MFA - All Users - All Cloud Apps'
• Assignments: All Users (exclude break-glass account)
• Cloud Apps: All cloud apps
• Grant: Require multifactor authentication
• Session: Sign-in frequency = 12 hours
• Navigate to: Intune Admin Center > Devices > Compliance policies > Create policy
• Platform: Windows 10 and later
• Settings — Require BitLocker: Yes
• Settings — Require Secure Boot: Yes
• Settings — Minimum OS version: 10.0.19045 (Windows 10 22H2)
• Settings — Require antivirus: Yes (Microsoft Defender)
• Settings — Password: Require, minimum 12 characters

# Connect to Microsoft Graph with appropriate scopes
Connect-MgGraph -Scopes 'Policy.ReadWrite.ConditionalAccess','DeviceManagementConfiguration.ReadWrite.All'

# Create SharePoint site for Contract Management
Connect-SPOService -Url https://[tenant]-admin.sharepoint.com
New-SPOSite -Url https://[tenant].sharepoint.com/sites/Contracts -Owner admin@[tenant].com -StorageQuota 102400 -Title 'Firm Contracts' -Template STS#3

# Create document library structure via PnP PowerShell
Connect-PnPOnline -Url https://[tenant].sharepoint.com/sites/Contracts -Interactive
Add-PnPFolder -Name 'Templates' -Folder 'Shared Documents'
Add-PnPFolder -Name 'Templates/NDAs' -Folder 'Shared Documents'
Add-PnPFolder -Name 'Templates/Service-Agreements' -Folder 'Shared Documents'
Add-PnPFolder -Name 'Templates/Engagement-Letters' -Folder 'Shared Documents'
Add-PnPFolder -Name 'Templates/Contractor-Agreements' -Folder 'Shared Documents'
Add-PnPFolder -Name 'Generated-Drafts' -Folder 'Shared Documents'
Add-PnPFolder -Name 'Clause-Library' -Folder 'Shared Documents'

Step 3: Spellbook Account Setup and Licensing

Register for Spellbook enterprise accounts, configure the organization workspace, and establish the licensing structure. Contact Spellbook's sales team for MSP/volume pricing. The Team tier ($40/user/month) may suffice for initial rollout, but the Enterprise tier (~$300/user/month) provides clause benchmarking, custom playbooks, and priority support that most firms will need for production use.

Step 4: Deploy Spellbook Word Add-in via Microsoft Intune

Deploy the Spellbook Microsoft Word add-in to all attorney and paralegal workstations using Microsoft Intune's centralized add-in deployment. This ensures consistent deployment across all devices without requiring individual users to install the add-in manually. The add-in integrates directly into the Word ribbon, providing AI drafting capabilities within the attorney's existing workflow.

# Method 1: Deploy via Microsoft 365 Admin Center (Integrated Apps)
# 1. Sign in to https://admin.microsoft.com
# 2. Navigate to: Settings > Integrated Apps > Get Apps
# 3. Search for 'Spellbook' in the Office Add-ins store
# 4. Click 'Deploy' (or 'Add' then 'Deploy')
# 5. Assign to: Specific users/groups (create a security group first)

# Create a security group for Spellbook users in Entra ID
Connect-MgGraph -Scopes 'Group.ReadWrite.All'
$group = New-MgGroup -DisplayName 'Spellbook-Licensed-Users' -MailEnabled:$false -MailNickname 'spellbook-users' -SecurityEnabled:$true -Description 'Users licensed for Spellbook AI contract drafting'

# Add attorney users to the group
$attorneys = @('jsmith@lawfirm.com','jdoe@lawfirm.com','mwilson@lawfirm.com')
foreach ($user in $attorneys) {
    $userId = (Get-MgUser -Filter "userPrincipalName eq '$user'").Id
    New-MgGroupMember -GroupId $group.Id -DirectoryObjectId $userId
}

# Method 2: If not available in store, deploy via Intune as LOB app
# 1. Obtain the Spellbook add-in manifest XML from Spellbook support
# 2. Navigate to: Intune Admin Center > Apps > All Apps > Add
# 3. App type: 'Microsoft 365 Apps - Office Add-in'
# 4. Upload manifest XML file
# 5. Assign to the 'Spellbook-Licensed-Users' group
# 6. Set assignment type: Required

# Verify deployment status
# Intune Admin Center > Apps > All Apps > Spellbook > Device install status

Step 5: Configure Clio Manage Integration (if applicable)

If the firm uses Clio Manage as their practice management system, configure the integration between Clio and the contract drafting workflow. This allows client and matter data to auto-populate contract templates, eliminating manual data entry. If the firm uses a different practice management system, adapt this step to configure the appropriate integration (Smokeball, PracticePanther, etc.) or use Zapier/Power Automate as a bridge.

• Clio API integration setup
• Log in to Clio Manage as an admin user
• Navigate to: Settings > API > Applications
• Register a new application: Name: 'Contract Drafting Integration', Redirect URI: per integration requirements, Scopes: contacts.read, matters.read, documents.read, documents.write
• Note the Client ID and Client Secret (store in Keeper password manager)
• If using Gavel for document automation with Clio: In Gavel: Settings > Integrations > Clio, Click 'Connect to Clio', Authorize Gavel to access Clio data, Map fields: Client Name, Matter Name, Matter Number, etc.
• If using Power Automate as middleware: Navigate to https://make.powerautomate.com, Create a new flow: 'Automated - When a new matter is created in Clio', Trigger: Clio webhook (new matter created), Action: Create folder in SharePoint: /Contracts/Generated-Drafts/{MatterName}, Action: Notify assigned attorney via Teams message
• Configure DocuSign integration with Clio: In Clio: Settings > Integrations > DocuSign, Connect DocuSign account, Enable: Auto-save signed documents back to Clio matter

Step 6: Template Migration and AI-Enablement

This is the most labor-intensive and critical phase. Convert the firm's existing Word contract templates into AI-enabled templates that Spellbook (or Clio Draft) can use to generate first drafts. This involves: (1) cleaning up existing templates to use consistent formatting and variable placeholders, (2) building a clause library from the firm's preferred language, (3) configuring Spellbook's contract playbooks with the firm's specific preferences and risk tolerances, and (4) testing each template to verify accurate generation.

# Standardize variable placeholders across Word contract templates and
# upload to SharePoint

# Template Cleanup Script (PowerShell) — Standardize variable placeholders
# Run this on each template to identify and standardize merge fields

$templatePath = 'C:\Templates\MutualNDA_Template.docx'
$word = New-Object -ComObject Word.Application
$word.Visible = $false
$doc = $word.Documents.Open($templatePath)

# List all content controls and bookmarks
foreach ($cc in $doc.ContentControls) {
    Write-Output "Content Control: $($cc.Title) | Tag: $($cc.Tag) | Type: $($cc.Type)"
}
foreach ($bm in $doc.Bookmarks) {
    Write-Output "Bookmark: $($bm.Name) | Range: $($bm.Range.Text)"
}

$doc.Close()
$word.Quit()

# Template Variable Naming Convention (standardize across all templates):
# {{PARTY_A_NAME}} - Disclosing/first party full legal name
# {{PARTY_A_ADDRESS}} - First party address
# {{PARTY_B_NAME}} - Receiving/second party full legal name
# {{PARTY_B_ADDRESS}} - Second party address
# {{EFFECTIVE_DATE}} - Agreement effective date
# {{GOVERNING_LAW_STATE}} - Governing law jurisdiction
# {{CONFIDENTIALITY_PERIOD}} - Duration of confidentiality obligation
# {{TERM_MONTHS}} - Agreement term in months
# {{ATTORNEY_NAME}} - Drafting attorney name
# {{ATTORNEY_BAR_NUMBER}} - Drafting attorney bar number

# Upload cleaned templates to SharePoint
Connect-PnPOnline -Url https://[tenant].sharepoint.com/sites/Contracts -Interactive
Add-PnPFile -Path 'C:\Templates\MutualNDA_Template_v2.docx' -Folder 'Shared Documents/Templates/NDAs'
Add-PnPFile -Path 'C:\Templates\OneWayNDA_Template_v2.docx' -Folder 'Shared Documents/Templates/NDAs'
Add-PnPFile -Path 'C:\Templates\MSA_Template_v2.docx' -Folder 'Shared Documents/Templates/Service-Agreements'
Add-PnPFile -Path 'C:\Templates\EngagementLetter_Template_v2.docx' -Folder 'Shared Documents/Templates/Engagement-Letters'
Add-PnPFile -Path 'C:\Templates\ContractorAgreement_Template_v2.docx' -Folder 'Shared Documents/Templates/Contractor-Agreements'

Step 7: Configure Spellbook Playbooks and Clause Library

Set up Spellbook's playbook feature to codify the firm's negotiation positions, preferred clause language, and risk tolerances. Playbooks tell the AI what the firm considers standard, acceptable, and unacceptable in each contract type. The clause library stores the firm's pre-approved language for common provisions. Together, these ensure AI-generated drafts align with the firm's specific standards rather than generic legal language.

Step 8: Configure DocuSign Integration for Contract Execution

Set up the end-to-end workflow from AI-generated draft to electronic signature. Configure DocuSign so that once an attorney approves an AI-generated contract, it can be sent for signature directly from Word or Clio with minimal friction. Set up templates in DocuSign that match the firm's common contract types, with pre-configured signature blocks and routing.

Step 9: Establish AI Usage Policy and Compliance Documentation

Create and deploy a written AI Usage Policy for the firm that satisfies ABA Formal Opinion 512 requirements. This policy must address: competence obligations, confidentiality protections, client communication/consent requirements, supervision responsibilities, and fee reasonableness. The MSP prepares the technical sections; the firm's managing partner must review and approve the legal/ethical sections.

• Create Document 1: AI Usage Policy (template provided in custom_ai_components) and store in SharePoint > Firm Policies
• Create Document 2: AI Vendor Due Diligence Checklist (completed for Spellbook) and store in SharePoint > Firm Policies
• Create Document 3: Client Consent Form for AI-Assisted Drafting and store in SharePoint > Firm Policies
• Create Document 4: AI-Generated Document Review Checklist and store in SharePoint > Firm Policies
• Create Document 5: Training Completion Log (track who has been trained) and store in SharePoint > Firm Policies
• Store vendor security artifact: Spellbook SOC 2 Type II Report (PDF)
• Store vendor security artifact: Spellbook Data Processing Agreement (signed PDF)
• Store vendor security artifact: Spellbook Zero Data Retention Confirmation (email/letter)
• Store vendor security artifact: DocuSign SOC 2 Type II Report (PDF)
• Store vendor security artifact: Clio SOC 2 Type II Report (PDF, if using Clio)
• SharePoint folder path: /Firm-Policies/AI-Compliance/
• Upload all documents and set permissions: Attorneys = Read, Admin = Edit

Step 10: User Training and Phased Rollout

Conduct structured training for all users in three tiers: (1) AI Champions / Admins — deep technical training on template management, playbook configuration, and troubleshooting; (2) Attorneys — workflow training on generating drafts, reviewing AI output, and using clause suggestions; (3) Paralegals/Staff — training on initiating draft requests, managing document workflows, and filing generated contracts. Roll out in phases: pilot group of 2–3 attorneys for 2 weeks, then expand to full firm.

• Week 1: AI Champion Training (2 sessions x 2 hours) — Session 1: Spellbook Admin Console: user management, playbook editing, clause library management, template upload and configuration, usage analytics and reporting. Session 2: Integration Management: Clio ↔ Spellbook data flow, DocuSign workflow configuration, troubleshooting common issues.
• Week 1: Pilot Group Training (1 session x 90 minutes) — 2–3 attorneys + 1 paralegal. Live demonstration: Generate an NDA from scratch. Hands-on exercise: Each attorney generates a contract from their matters. Review AI output together: What to check, common issues. Feedback collection for template/playbook refinement.
• Week 2: Pilot Group Production Use — Attorneys use Spellbook for real (non-urgent) contract drafts. MSP monitors usage and collects feedback daily. Adjust templates and playbooks based on attorney feedback.
• Week 3: Full Attorney Training (2 sessions x 90 minutes) — Session 1: All attorneys — live demo + hands-on. Session 2: All attorneys — advanced features + Q&A.
• Week 3: Paralegal/Staff Training (1 session x 60 minutes) — Document workflow: request → generate → review → sign → file. SharePoint folder structure and naming conventions. Escalation process for AI tool issues.
• Record all training sessions (Teams recording) and store in SharePoint.
• Have each attendee sign the Training Completion Log.

Step 11: Go-Live Monitoring and Hypercare Period

After full rollout, enter a 2-week hypercare period where the MSP provides elevated support. Monitor Spellbook usage analytics daily, respond to user issues within 1 hour during business hours, and make real-time adjustments to templates and playbooks based on attorney feedback. Track key metrics: contracts generated per day, average generation time, attorney satisfaction scores, and revision rates (how much attorneys change AI-generated drafts).

• Set up monitoring dashboard (use Power BI or simple SharePoint list)
• Metric 1: Contracts generated per day (from Spellbook analytics)
• Metric 2: Average time from request to first draft
• Metric 3: User adoption rate (active users / licensed users)
• Metric 4: Support tickets related to AI drafting
• Metric 5: Attorney revision rate (% of AI draft that requires manual editing)
• Set up a Teams channel for real-time support: Teams > Create Channel: 'AI Contract Drafting Support'
• Pin quick reference guides and FAQ documents
• MSP technician monitors channel during business hours (8AM–6PM)
• Create a feedback form (Microsoft Forms) with fields: User name, Contract type generated, Satisfaction (1–5), What worked well, What needs improvement, Time saved estimate
• Share form link in the Teams support channel

Custom AI Components

NDA Generation Prompt Template

Type: prompt A structured prompt template for generating Mutual NDAs from firm templates using Spellbook or a direct LLM API. This prompt incorporates the firm's standard clause preferences, variable placeholders, and quality control instructions. It is designed to be used within Spellbook's custom prompt feature or as a standalone prompt if using the OpenAI/Anthropic API directly.

Implementation:

Master Service Agreement Generation Prompt

Type: prompt A structured prompt template for generating Master Service Agreements (MSAs) that cover the firm's standard terms for ongoing service relationships. This handles the more complex contract type with payment terms, IP provisions, indemnification, limitation of liability, and service-specific schedules.

Implementation:

Contract Review Quality Checklist Agent

Type: agent An automated quality assurance workflow that reviews AI-generated contracts against the firm's playbook requirements before presenting the draft to an attorney. This agent checks for: (1) all required sections present, (2) no placeholder variables left unfilled, (3) clause language matches firm clause library, (4) no conflicting provisions, (5) governing law and jurisdiction are correct, and (6) risk flags for unusual terms. Implemented as a Power Automate flow triggered when a new document is saved to the Generated-Drafts SharePoint folder.

Implementation

# Power Automate Flow: Contract Review Quality Checklist
# Trigger: When a file is created in SharePoint > Contracts > Generated-Drafts

# Flow Definition (pseudo-YAML for Power Automate):

flow_name: AI Contract QA Review
trigger:
  type: SharePoint - When a file is created
  site: https://[tenant].sharepoint.com/sites/Contracts
  library: Shared Documents/Generated-Drafts

steps:
  - action: Get file content
    inputs:
      site: $trigger.site
      file_id: $trigger.file_id

  - action: Convert Word to Text
    description: Extract text content from .docx for analysis
    inputs:
      file_content: $previous.content

  - action: Compose - Build QA Prompt
    inputs:
      value: |
        You are a legal document quality assurance reviewer. Analyze the following contract draft and return a JSON object with these checks:
        
        {
          "document_type": "[NDA/MSA/Engagement Letter/Other]",
          "unfilled_placeholders": ["list any {{VARIABLE}} still present"],
          "missing_required_sections": ["list any standard sections missing for this document type"],
          "governing_law_state": "[extracted state or 'MISSING']",
          "dispute_resolution_method": "[extracted method or 'MISSING']",
          "risk_flags": [
            {
              "section": "section name",
              "issue": "description of potential risk",
              "severity": "HIGH/MEDIUM/LOW"
            }
          ],
          "draft_watermark_present": true/false,
          "signature_blocks_complete": true/false,
          "overall_quality_score": 1-10,
          "recommendation": "APPROVE FOR REVIEW / NEEDS REVISION / REJECT"
        }
        
        CONTRACT TEXT:
        ---
        $previous.text_content
        ---

  - action: HTTP - Call OpenAI API
    inputs:
      method: POST
      uri: https://api.openai.com/v1/chat/completions
      headers:
        Authorization: Bearer $env.OPENAI_API_KEY
        Content-Type: application/json
      body:
        model: gpt-5.4
        messages:
          - role: system
            content: You are a legal document QA reviewer. Return only valid JSON.
          - role: user
            content: $previous.value
        temperature: 0.1
        response_format: { type: json_object }

  - action: Parse JSON
    inputs:
      content: $previous.body.choices[0].message.content

  - condition: overall_quality_score >= 7 AND recommendation == 'APPROVE FOR REVIEW'
    true_branch:
      - action: Update file properties in SharePoint
        inputs:
          QA_Status: Passed
          QA_Score: $parsed.overall_quality_score
          QA_Date: utcNow()
      - action: Send Teams notification to assigned attorney
        inputs:
          channel: AI Contract Drafting Support
          message: |
            ✅ **Contract Draft Ready for Review**
            📄 File: $trigger.file_name
            📊 QA Score: $parsed.overall_quality_score/10
            ⚠️ Risk Flags: $parsed.risk_flags.length
            👉 [Open Document]($trigger.file_url)
    false_branch:
      - action: Update file properties in SharePoint
        inputs:
          QA_Status: Needs Revision
          QA_Score: $parsed.overall_quality_score
          QA_Issues: $parsed.missing_required_sections + $parsed.unfilled_placeholders
      - action: Send Teams notification to drafter
        inputs:
          message: |
            ⚠️ **Contract Draft Needs Revision**
            📄 File: $trigger.file_name
            📊 QA Score: $parsed.overall_quality_score/10
            🔴 Issues Found:
            - Unfilled placeholders: $parsed.unfilled_placeholders
            - Missing sections: $parsed.missing_required_sections
            - Risk flags: $parsed.risk_flags
            👉 [Open Document]($trigger.file_url)

# OpenAI API Cost Estimate:
# ~2,000 input tokens + ~500 output tokens per review
# At GPT-5.4 pricing ($2.50/M input, $10/M output):
# Cost per review: ~$0.01
# 100 contracts/month: ~$1.00/month

Client Intake to Contract Generation Workflow

Type: workflow An end-to-end automation workflow that connects client intake (via Clio Grow or Microsoft Forms) to contract generation. When a new matter is opened with a contract-type tag, the workflow automatically collects required variables, generates a first draft using the appropriate prompt template, runs QA, and notifies the assigned attorney. This eliminates the manual process of gathering information and initiating drafts. Implementation:

# Workflow: Client Intake → Contract Auto-Generation
# Platform: Power Automate (Microsoft 365)
# Prerequisites: Clio API connection, Spellbook or OpenAI API key, SharePoint site

# TRIGGER OPTIONS (choose one based on firm's intake process):

# Option A: Triggered by new Clio Matter with contract tag
trigger_a:
  type: HTTP Webhook (Clio webhook)
  event: matter.created
  filter: matter.practice_area IN ['Corporate', 'Business Law', 'Contracts']

# Option B: Triggered by Microsoft Form submission
trigger_b:
  type: Microsoft Forms - When a new response is submitted
  form_id: [Contract Request Form ID]

# MICROSOFT FORMS TEMPLATE for Contract Request:
# Field 1: Contract Type (Choice: Mutual NDA, One-Way NDA, MSA, Engagement Letter, Contractor Agreement)
# Field 2: Clio Matter Number (Text)
# Field 3: Party A - Full Legal Name (Text)
# Field 4: Party A - Entity Type (Choice: Corporation, LLC, Partnership, Individual, Other)
# Field 5: Party A - State of Organization (Text)
# Field 6: Party A - Address (Long Text)
# Field 7: Party B - Full Legal Name (Text)
# Field 8: Party B - Entity Type (Choice)
# Field 9: Party B - State of Organization (Text)
# Field 10: Party B - Address (Long Text)
# Field 11: Effective Date (Date)
# Field 12: Governing Law State (Text, default: firm's state)
# Field 13: Special Instructions (Long Text, optional)
# Field 14: Requesting Attorney (Choice: list of attorneys)
# Field 15: Priority (Choice: Standard, Rush)

# WORKFLOW STEPS:

steps:
  1_get_form_data:
    action: Get response details from Microsoft Forms
    outputs: contract_type, matter_number, party_a_*, party_b_*, effective_date, governing_law, special_instructions, requesting_attorney, priority

  2_get_clio_matter:
    action: HTTP GET to Clio API
    url: https://app.clio.com/api/v4/matters/{matter_number}.json
    headers:
      Authorization: Bearer $env.CLIO_ACCESS_TOKEN
    outputs: matter_name, client_name, responsible_attorney

  3_select_prompt_template:
    action: Switch on contract_type
    cases:
      'Mutual NDA': load NDA_Generation_Prompt_Template
      'One-Way NDA': load OneWay_NDA_Prompt_Template
      'MSA': load MSA_Generation_Prompt_Template
      'Engagement Letter': load Engagement_Letter_Prompt_Template
      'Contractor Agreement': load Contractor_Agreement_Prompt_Template

  4_populate_prompt:
    action: Compose
    description: Replace all {{VARIABLES}} in selected template with form data
    inputs:
      template: $step3.prompt_template
      replacements:
        FIRM_NAME: '[Firm Name]'
        FIRM_STATE: '[Firm State]'
        PARTY_A_NAME: $step1.party_a_name
        PARTY_A_ENTITY_TYPE: $step1.party_a_entity_type
        PARTY_A_STATE: $step1.party_a_state
        PARTY_A_ADDRESS: $step1.party_a_address
        PARTY_B_NAME: $step1.party_b_name
        PARTY_B_ENTITY_TYPE: $step1.party_b_entity_type
        PARTY_B_STATE: $step1.party_b_state
        PARTY_B_ADDRESS: $step1.party_b_address
        EFFECTIVE_DATE: $step1.effective_date
        GOVERNING_LAW_STATE: $step1.governing_law
        SPECIAL_INSTRUCTIONS: $step1.special_instructions

  5_generate_via_spellbook_or_api:
    # Option A: If using Spellbook API (when available)
    action: HTTP POST to Spellbook API
    # Option B: If using OpenAI directly
    action: HTTP POST
    url: https://api.openai.com/v1/chat/completions
    headers:
      Authorization: Bearer $env.OPENAI_API_KEY
      Content-Type: application/json
    body:
      model: gpt-5.4
      messages:
        - role: system
          content: $step4.system_prompt
        - role: user
          content: $step4.user_prompt
      temperature: 0.3
      max_tokens: 8000

  6_convert_to_word:
    action: Create Word document from text
    description: Use the Word Online connector or a custom function to create a properly formatted .docx
    filename: '{contract_type}_{party_b_name}_{date}_DRAFT.docx'

  7_save_to_sharepoint:
    action: Create file in SharePoint
    site: https://[tenant].sharepoint.com/sites/Contracts
    folder: Shared Documents/Generated-Drafts/{matter_number}
    filename: $step6.filename
    content: $step6.file_content
    metadata:
      Contract_Type: $step1.contract_type
      Matter_Number: $step1.matter_number
      Requesting_Attorney: $step1.requesting_attorney
      Generation_Date: utcNow()
      Status: 'Pending QA Review'

  8_trigger_qa_review:
    description: The QA Agent (separate flow) auto-triggers when file is saved to Generated-Drafts
    note: See Contract Review Quality Checklist Agent

  9_notify_attorney:
    action: Send Teams chat message
    recipient: $step1.requesting_attorney
    message: |
      📄 **New Contract Draft Generated**
      Type: $step1.contract_type
      Matter: $step2.matter_name
      Parties: $step1.party_a_name ↔ $step1.party_b_name
      Status: Pending QA → Attorney Review
      Priority: $step1.priority
      👉 [Open Draft]($step7.file_url)
      
      ⚠️ REMINDER: All AI-generated drafts require attorney review before delivery to any party.

  10_log_to_clio:
    action: HTTP POST to Clio API
    url: https://app.clio.com/api/v4/activities.json
    body:
      data:
        type: TimeEntry (non-billable) or Note
        matter: { id: $step2.matter_id }
        description: 'AI-generated {contract_type} draft created. Pending attorney review.'
        date: utcNow()

AI Usage Policy Template for Law Firms

A comprehensive, ready-to-customize AI Usage Policy document that satisfies ABA Formal Opinion 512 requirements. This policy template is delivered to the firm as part of the compliance documentation package. The managing partner reviews, customizes, and formally adopts it. Implementation:

Clause Library Import Utility

Type: integration A PowerShell utility script that batch-imports the firm's existing clause language from Word documents into a structured clause library stored in SharePoint. Each clause is tagged with metadata (contract type, section, risk level, version) for easy retrieval by attorneys and the AI drafting system. This utility is run during the template migration phase (Step 6) and can be re-run whenever new clauses are added.

Implementation:

# Batch-imports clause documents from a local folder into SharePoint with
# structured metadata tagging.

# Clause Library Import Utility
# PowerShell Script: Import-ClauseLibrary.ps1
# Prerequisites: PnP.PowerShell module, Microsoft Word COM object
# Usage: .\Import-ClauseLibrary.ps1 -SourceFolder 'C:\FirmClauses' -SharePointSite 'https://[tenant].sharepoint.com/sites/Contracts'

param(
    [Parameter(Mandatory=$true)]
    [string]$SourceFolder,
    
    [Parameter(Mandatory=$true)]
    [string]$SharePointSite,
    
    [string]$LibraryName = 'Shared Documents/Clause-Library',
    
    [string]$MetadataFile = 'clause_metadata.csv'
)

# clause_metadata.csv format:
# FileName,ClauseName,ContractType,Section,RiskLevel,Version,Notes
# Confidentiality_Standard.docx,Standard Confidentiality,All,Confidentiality,Low,1.0,Default for all contracts
# Confidentiality_Enhanced.docx,Enhanced Confidentiality,NDA;MSA,Confidentiality,Low,1.0,For trade secret matters
# Indemnification_Mutual.docx,Mutual Indemnification,MSA,Indemnification,Medium,1.0,Preferred position
# Indemnification_OneWay.docx,One-Way Indemnification (Provider),MSA,Indemnification,High,1.0,Fallback position
# LimitationOfLiability_Capped.docx,Liability Cap (12mo fees),MSA,Limitation of Liability,Medium,1.0,Standard cap
# ForceMAjeure_Standard.docx,Standard Force Majeure,All,Force Majeure,Low,1.0,Post-COVID updated
# GoverningLaw_NY.docx,New York Governing Law,All,Governing Law,Low,1.0,Default jurisdiction
# DisputeResolution_Arbitration.docx,AAA Arbitration,All,Dispute Resolution,Medium,1.0,Preferred method
# NonSolicitation_12mo.docx,12-Month Non-Solicitation,MSA,Non-Solicitation,Medium,1.0,Mutual obligation

Write-Host '=== Clause Library Import Utility ===' -ForegroundColor Cyan
Write-Host "Source: $SourceFolder"
Write-Host "Target: $SharePointSite/$LibraryName"

# Connect to SharePoint
Connect-PnPOnline -Url $SharePointSite -Interactive

# Load metadata
$metadataPath = Join-Path $SourceFolder $MetadataFile
if (-not (Test-Path $metadataPath)) {
    Write-Error "Metadata file not found: $metadataPath"
    Write-Host 'Create a clause_metadata.csv file with columns: FileName,ClauseName,ContractType,Section,RiskLevel,Version,Notes'
    exit 1
}

$metadata = Import-Csv $metadataPath
Write-Host "Found $($metadata.Count) clauses to import" -ForegroundColor Green

# Process each clause
$word = New-Object -ComObject Word.Application
$word.Visible = $false
$imported = 0
$errors = 0

foreach ($clause in $metadata) {
    $filePath = Join-Path $SourceFolder $clause.FileName
    
    if (-not (Test-Path $filePath)) {
        Write-Warning "File not found: $($clause.FileName) — skipping"
        $errors++
        continue
    }
    
    try {
        # Extract text content for indexing
        $doc = $word.Documents.Open($filePath)
        $textContent = $doc.Content.Text
        $wordCount = $doc.Words.Count
        $doc.Close()
        
        # Upload to SharePoint with metadata
        $spFile = Add-PnPFile -Path $filePath -Folder $LibraryName -Values @{
            'Title' = $clause.ClauseName
            'ContractType' = $clause.ContractType
            'ClauseSection' = $clause.Section
            'RiskLevel' = $clause.RiskLevel
            'Version' = $clause.Version
            'Notes' = $clause.Notes
            'WordCount' = $wordCount
            'ImportDate' = (Get-Date -Format 'yyyy-MM-dd')
        }
        
        Write-Host "  ✅ Imported: $($clause.ClauseName) ($wordCount words)" -ForegroundColor Green
        $imported++
    }
    catch {
        Write-Warning "  ❌ Failed to import $($clause.FileName): $_"
        $errors++
    }
}

$word.Quit()

Write-Host ''
Write-Host '=== Import Complete ===' -ForegroundColor Cyan
Write-Host "Imported: $imported | Errors: $errors | Total: $($metadata.Count)"
Write-Host ''
Write-Host 'Next steps:' -ForegroundColor Yellow
Write-Host '1. Verify clauses in SharePoint: $SharePointSite/$LibraryName'
Write-Host '2. Create SharePoint list views filtered by ContractType and Section'
Write-Host '3. Share Clause Library with attorney team for review'
Write-Host '4. Upload clause text to Spellbook Clause Library feature'

Contract Generation Metrics Dashboard

Type: integration A Power BI dashboard template that tracks contract generation metrics including: documents generated per day/week/month, generation time, attorney revision rates, user adoption, cost per document, and time savings. Connected to SharePoint metadata and Spellbook usage data. Used during hypercare and ongoing managed services to demonstrate ROI.

Implementation:

• Platform: Power BI (included in Microsoft 365 Business Premium)
• Data Sources: SharePoint List, Microsoft Forms survey data, manual Spellbook export

Step 1: Create SharePoint Tracking List

• List Name: 'Contract Generation Log'
• Title (Single line text) — auto-populated document name
• ContractType (Choice: Mutual NDA, One-Way NDA, MSA, Engagement Letter, Contractor Agreement, Other)
• MatterNumber (Single line text)
• RequestingAttorney (Person)
• GenerationDate (Date and Time)
• QAScore (Number, 1-10)
• QAStatus (Choice: Passed, Needs Revision, Rejected)
• AttorneyReviewComplete (Yes/No)
• AttorneyReviewDate (Date and Time)
• RevisionLevel (Choice: Minor <10%, Moderate 10-30%, Major >30%)
• SentForSignature (Yes/No)
• SignatureDate (Date and Time)
• EstimatedTimeSavedMinutes (Number)
• AIToolUsed (Choice: Spellbook, Clio Draft, Manual)

Step 2: Power BI Dashboard Pages

• Page 1: Executive Summary — KPI Cards: Total Contracts Generated (This Month / Last Month / % Change), Average Time Saved per Contract (minutes), Total Hours Saved (This Month), User Adoption Rate (Active Users / Licensed Users %), Average QA Score, Cost per Document (AI subscription cost / documents generated)
• Page 2: Generation Analytics — Bar Chart: Contracts by Type (NDA, MSA, etc.) monthly trend; Line Chart: Contracts Generated per Week (12-week trend); Pie Chart: Distribution by Requesting Attorney; Table: Recent Generations with QA Score and Status
• Page 3: Quality Metrics — Gauge: Average QA Score (target: 8+); Stacked Bar: Revision Level Distribution (Minor/Moderate/Major); Line Chart: QA Score Trend Over Time (should improve); Table: Documents Flagged for Major Revision (drill-down)
• Page 4: ROI Calculator — Slicers: Average attorney hourly rate, Average manual drafting time per contract type, Monthly AI tool cost

Step 3: Power BI Connection Setup

DAX Measures for Key Calculations

Total Contracts = COUNTROWS('Contract Generation Log')
Avg QA Score = AVERAGE('Contract Generation Log'[QAScore])
Adoption Rate = DISTINCTCOUNT('Contract Generation Log'[RequestingAttorney]) / [Total Licensed Users]
Avg Time Saved = AVERAGE('Contract Generation Log'[EstimatedTimeSavedMinutes])
Monthly ROI = [Value of Time Saved] - [Monthly AI Cost]
Documents This Month = CALCULATE(COUNTROWS('Contract Generation Log'), DATESMTD('Contract Generation Log'[GenerationDate]))

ROI Calculated Measures

# plug in attorney hourly rate and AI tool cost via slicers

Time_Saved_Hours = SUM(EstimatedTimeSavedMinutes) / 60
Value_of_Time_Saved = Time_Saved_Hours * Attorney_Hourly_Rate
Monthly_AI_Cost = [from software procurement data]
Net_ROI = Value_of_Time_Saved - Monthly_AI_Cost
ROI_Percentage = (Net_ROI / Monthly_AI_Cost) * 100

Testing & Validation

• TEST 1 — Spellbook Add-in Installation Verification: Open Microsoft Word on 3 different user workstations (attorney laptop, paralegal desktop, remote attorney VPN). Navigate to Insert > My Add-ins > Admin Managed. Verify 'Spellbook' appears in the list. Click to activate and confirm the Spellbook panel opens in the Word ribbon. Expected result: Add-in loads within 5 seconds and authenticates via SSO without prompting for separate credentials.
• TEST 2 — Mutual NDA Generation End-to-End: Using the NDA Generation Prompt Template with sample data (fictional parties: 'Acme Corp' and 'Widget Inc'), generate a complete Mutual NDA via Spellbook in Word. Verify: (a) all 18 required sections are present, (b) no {{PLACEHOLDER}} variables remain, (c) governing law matches firm default, (d) '[DRAFT - ATTORNEY REVIEW REQUIRED]' watermark is present, (e) signature blocks are properly formatted. Time the generation and confirm it completes within 2 minutes.
• TEST 3 — Master Service Agreement Generation: Generate a complete MSA using the MSA prompt template with sample data. Verify all 20 required sections are present, fee structure is correctly populated, IP ownership clause reflects firm defaults (client owns work product), and limitation of liability cap is correctly stated. Have a senior attorney review the output and score it on a 1–10 quality scale. Target: 7+ on first generation.
• TEST 4 — Clause Library Retrieval: In Spellbook, request an alternative indemnification clause. Verify the AI suggests language that matches (or closely aligns with) the firm's pre-loaded clause library entries. Test with 3 different clause types: confidentiality, limitation of liability, and force majeure. Confirm the firm's preferred language appears as a suggestion option.
• TEST 5 — QA Agent Functionality: Save a deliberately flawed contract draft to the SharePoint Generated-Drafts folder (include 2 unfilled {{PLACEHOLDER}} variables, omit the governing law section, and remove the draft watermark). Verify the Power Automate QA flow triggers within 5 minutes, correctly identifies all 3 issues, assigns a quality score below 7, and sends a Teams notification to the drafter with specific remediation instructions.
• TEST 6 — Clio Integration Data Flow: Create a test matter in Clio Manage with complete client data. Submit a contract request via the Microsoft Forms intake form referencing that matter number. Verify that: (a) the Power Automate flow triggers, (b) client and matter data are correctly pulled from Clio API, (c) the generated contract contains the correct party information from Clio, and (d) an activity entry is logged in the Clio matter.
• TEST 7 — DocuSign Signing Workflow: Take an attorney-approved NDA draft, send it for signature via the DocuSign Word add-in. Verify: (a) signature fields are correctly placed, (b) both parties receive signing emails, (c) the signed document is automatically saved back to the SharePoint matter folder, (d) if Clio integration is active, the signed document appears in the Clio matter. Complete a full round-trip signing with a test signer.
• TEST 8 — Security and Access Control: Attempt to access Spellbook from an unmanaged personal device — verify Conditional Access blocks the attempt. Attempt to log in without MFA — verify access is denied. Log in as a 'Drafter' role user and attempt to edit a playbook — verify the action is restricted to Admin/Editor roles. Verify audit logs capture all access attempts in Azure AD sign-in logs.
• TEST 9 — Concurrent User Performance: Have 5 attorneys simultaneously generate different contract types via Spellbook in Word. Verify: (a) no degradation in response time (each generation completes within 3 minutes), (b) no cross-contamination of data between users, (c) all 5 generated documents are correctly saved to their respective SharePoint matter folders with accurate metadata.
• TEST 10 — Disaster Recovery: Simulate a scenario where a generated contract is accidentally deleted from SharePoint. Verify recovery via: (a) SharePoint Recycle Bin (first-stage, 93-day retention), (b) Datto SaaS Protection point-in-time restore. Confirm the recovered document matches the original including all metadata. Document recovery time — target: under 15 minutes.
• TEST 11 — Compliance Validation: Review the completed AI Usage Policy with the managing partner. Verify: (a) all sections from the template are customized for the firm, (b) the policy has been formally signed by the managing partner, (c) all attorneys have signed the acknowledgment form, (d) vendor security artifacts (SOC 2 reports, DPAs, zero data retention confirmations) are on file in the compliance folder, (e) the engagement letter template includes AI disclosure language.
• TEST 12 — ROI Metrics Baseline: After 2 weeks of pilot use, verify the Power BI dashboard shows: (a) accurate contract count matching Spellbook usage logs, (b) calculated time savings based on attorney-reported estimates, (c) QA score trending data, (d) per-attorney adoption metrics. Compare dashboard data against manual counts to verify accuracy within 5% margin.

Client Handoff

The client handoff should be conducted as a formal 2-hour meeting with the managing partner, AI Champion, and at least one representative from each user tier (attorney, paralegal, admin). Cover the following:

Maintenance

• Review Spellbook usage analytics: active users, documents generated, feature utilization. Flag any users with zero usage for re-training outreach.
• Verify all software subscriptions are active and licenses are correctly assigned. Reconcile Spellbook seat count with actual users.
• Review and apply Microsoft 365 updates via Intune. Ensure Word add-ins remain functional after updates.
• Check Azure AD sign-in logs for anomalous access patterns to AI tools. Review Conditional Access policy effectiveness.
• Verify Datto SaaS Protection backups are completing successfully. Perform one test restore per quarter.
• Monitor SharePoint storage utilization for the Contracts site. Alert if approaching 80% of allocated quota.
• Review and respond to any QA agent alerts that were not addressed by attorneys.

• Conduct Quarterly Business Review (QBR) with managing partner and AI Champion. Present Power BI dashboard metrics, ROI analysis, and usage trends.
• Review and update clause library: add new clauses approved by attorneys, retire outdated language, update version numbers.
• Review and update playbook configurations: adjust default positions, risk tolerances, and mandatory clause lists based on attorney feedback and legal developments.
• Verify vendor security compliance: check for updated SOC 2 reports, review any vendor security advisories, confirm zero data retention status.
• Review AI Usage Policy for needed updates: new AI tools, new state bar guidance, new regulations.
• Test disaster recovery: perform a full contract recovery test from Datto backup.
• Review and update Microsoft 365 security posture: Secure Score, Conditional Access policies, MFA enrollment status.

• Formal AI Usage Policy review and re-acknowledgment by all attorneys.
• Vendor contract renewal review: evaluate pricing, negotiate volume discounts, assess competitive alternatives.
• Comprehensive security audit: penetration test, access review, license reconciliation.
• Strategic planning session: identify new contract types for AI enablement, evaluate new AI tools entering the market, plan template expansion.
• CLE tracking: ensure attorneys have completed technology/AI-related continuing education.

• New attorney onboarding: provision Spellbook license, deploy Word add-in, conduct 1:1 training session, add to security groups, update AI Usage Policy acknowledgment log.
• Attorney departure: revoke Spellbook license, remove from security groups, transfer template ownership if applicable, audit recent AI-generated documents.
• Vendor security incident: immediate assessment of impact, communication to firm, potential tool suspension pending investigation.
• Major AI platform update: test in sandbox/pilot group before full rollout, update training materials, notify users of new features or changed workflows.
• New state bar AI guidance: review guidance, update AI Usage Policy if needed, communicate changes to attorneys.

• Critical issues (AI tool completely unavailable, data security concern): 1-hour response, 4-hour resolution target
• High priority (AI tool degraded performance, integration failure): 4-hour response, 8-hour resolution target
• Standard (template updates, user provisioning, training requests): 8-hour response, 24-hour resolution target
• Low priority (feature requests, dashboard customization, policy updates): 24-hour response, 5-business-day resolution target

Escalation Path: L1 MSP Help Desk → L2 MSP Cloud Engineer → L3a Spellbook Vendor Support (support@spellbook.legal) → L3b Clio Support (support@clio.com) → L3c Microsoft Premier Support (for M365/Azure AD issues)

Alternatives

Clio-Centric Stack (Clio Manage + Clio Work with Draft AI)

Replace Spellbook with Clio Work ($199/user/month) as the AI drafting engine, running entirely within the Clio ecosystem. Clio Draft AI converts existing templates into AI-enabled documents and generates contracts from matter data. Combined with Clio Manage ($89–$149/user/month), this provides a single-vendor solution for practice management, AI drafting, document management, and billing. Vincent AI adds legal research and intelligence capabilities.

Robin AI for Mid-Market Firms

Use Robin AI as the primary contract drafting and management platform. Robin AI provides a Word add-in similar to Spellbook but adds contract lifecycle management (CLM) capabilities including obligation tracking, renewal management, and advanced reporting. Pricing starts at approximately $3,000–$8,000/year for small teams. Recently listed in AWS Marketplace and actively targeting the 60,000+ small and mid-sized law firm segment.

Budget Stack: Gavel + Microsoft Copilot for M365

For cost-sensitive solo practitioners or small firms (1–3 attorneys), use Gavel ($83–$160/user/month) for template-based document automation combined with Microsoft Copilot for M365 ($30/user/month) for general AI assistance in Word. Gavel handles the structured template logic (conditional clauses, variable population, client intake forms), while Copilot assists with language refinement and clause suggestions within Word.

Custom Build with OpenAI GPT-5.4 API + Power Automate