How to Push Dataset Updates with Microsoft Intune (No Cloud Needed)

Become the administrator who ships critical Artificial Intelligence updates across your organization's computing fleet before lunch. With Iternal Technologies' AirgapAI, your valuable data stays securely inside your network's walls, and your people remain unblocked and highly productive.

This comprehensive guide is tailored for Information Technology administrators, providing a step-by-step workflow for the reliable and secure distribution of AirgapAI dataset updates using Microsoft Intune. You will learn how to package Blockify datasets, target specific user folders on devices, schedule updates, verify their integrity using checksums, and establish robust rollback plans. Our approach champions air-gapped data governance, leveraging familiar enterprise tooling to ensure no data drift and absolutely no data leaks. Critical file paths and a change-management checklist are also included to streamline your deployment process.

1. Understanding AirgapAI and its Local Data Architecture

Before diving into the technical specifics of deploying updates, it's essential to understand what AirgapAI is and how it utilizes data locally on your organization's personal computers.

What is Artificial Intelligence?

Artificial Intelligence, often abbreviated as AI, refers to computer systems designed to perform tasks that typically require human intelligence. This can include understanding human language, recognizing patterns, making decisions, and learning from data.

What is a Large Language Model (LLM)?

A Large Language Model, often abbreviated as LLM, is a type of Artificial Intelligence program that can understand and generate human-like text. Think of it like a highly sophisticated chatbot that has read an enormous amount of text from the internet, allowing it to answer questions, write essays, summarize documents, and even translate languages.

The Problem with Cloud-Based Artificial Intelligence

Many popular Artificial Intelligence tools today, such as those that run in the cloud (over the internet), require your data to be sent outside your organization's secure network. This can pose significant risks:

Data Sovereignty and Security: Your confidential or proprietary information might leave your control, potentially residing on servers in other countries or being exposed to external threats.
Privacy Concerns: Sensitive employee or customer data could be inadvertently shared or compromised.
Cost: Cloud-based solutions often come with recurring subscription fees, hidden token charges, and overage bills, making them expensive to scale.
AI Hallucinations: Even with your own data, cloud Large Language Models can sometimes generate inaccurate or fabricated responses, leading to mistrust in the Artificial Intelligence.

How AirgapAI Solves These Challenges

AirgapAI, developed by Iternal Technologies, is a revolutionary solution designed specifically for businesses that need to leverage Artificial Intelligence without compromising security, control, or cost. Here's how it's different:

100% Local and Offline: AirgapAI runs entirely on the user's personal computer, such as a Dell Artificial Intelligence Personal Computer (AI PC). This means no data ever leaves the device, eliminating external network dependencies and ensuring complete data sovereignty. It can even operate in environments without internet connectivity, like a secure facility or a remote field operation.
Cost-Effective Perpetual License: Unlike cloud services with ongoing subscriptions, AirgapAI is sold as a one-time perpetual license per device. This significantly reduces licensing expenses, often costing as little as one-tenth to one-fifteenth of cloud alternatives.
Patented Blockify Technology for Accuracy: To combat Artificial Intelligence hallucinations and ensure trusted responses, AirgapAI incorporates Iternal Technologies' patented Blockify technology. This innovative process refines data inputs for highly accurate Large Language Model responses, improving accuracy by an astounding 7,800 percent, or 78 times.
Enterprise Deployment Friendly: AirgapAI is distributed as a standard executable application file (.exe) that integrates seamlessly into existing Information Technology imaging and provisioning workflows. This makes it easy for Information Technology administrators to deploy and manage across their entire fleet of devices.

AirgapAI's Data Storage Structure

Understanding where AirgapAI stores its critical data on a local device is paramount for managing dataset updates.

When AirgapAI is installed and configured, it creates specific folders within the user's application data directory. This ensures that each user profile can maintain its own isolated experiences and datasets on a shared device, if desired.

Key Data Path for Datasets:

The primary location for AirgapAI's customized datasets, which are processed by Blockify, is typically found within the user's AppData directory:

C:\Users\[Username]\AppData\Roaming\airgap-ai-chat\CorpusRepo

[Username] refers to the specific user's profile on the Windows operating system.
AppData\Roaming is a standard Windows directory used by applications to store user-specific data that roams with the user's profile.
airgap-ai-chat is the main application folder for AirgapAI Chat.
CorpusRepo is the specific repository where Blockify-generated datasets (the "blocks" of trusted information) are stored.

It's crucial for Information Technology administrators to note this path, as it will be the target destination for any dataset updates you push using Microsoft Intune.

2. Preparing Your Blockify Datasets for Deployment

The first step in updating your AirgapAI deployments is to prepare the actual datasets that your Large Language Models will use. These datasets are the "knowledge base" for your Artificial Intelligence, allowing it to answer questions specific to your organization's documents.

What is a Dataset in AirgapAI?

In the context of AirgapAI, a dataset is a collection of curated, high-quality information that has been optimized by Iternal Technologies' Blockify technology. Instead of feeding raw documents to an Artificial Intelligence, Blockify transforms large volumes of data (like sales documents, Request for Proposal responses, or technical manuals) into concise, modular "blocks" of trusted information.

Each block contains:

A Name: A clear identifier for the content topic.
A Critical Question: The key query a user might ask related to this content.
A Trusted Answer: A distilled, accurate response derived from your original documents, validated to avoid outdated or redundant information.

This process reduces the original data size significantly while dramatically improving the accuracy of the Artificial Intelligence's responses.

The Blockify Process: From Documents to Blocks

While this guide focuses on deploying already processed datasets, it's important to understand the origin:

Data Ingestion: Your raw documents (text, Hypertext Markup Language, Portable Document Format, Word documents, PowerPoint presentations, etc.) are fed into the Blockify system.
Distillation and Deduplication: Blockify intelligently processes and condenses this data, identifying key information and removing redundancies.
Block Creation: The system generates "blocks" of information, each tagged with rich metadata (including classification, permissions, and security levels) to support zero-trust environments.
Human Review (Optional but Recommended): Information Technology or subject matter experts can review these generated blocks to update or approve messaging, ensuring the Artificial Intelligence always uses the most current and accurate information.
Dataset Export: Once validated, the Blockify-processed data is exported in a format (typically .jsonl or similar structured data file) ready for use by AirgapAI.

Packaging Your Blockify Datasets

For deployment via Microsoft Intune, your Blockify datasets need to be packaged correctly.

Obtain the Latest Datasets: Work with your Iternal Technologies contact or your internal Blockify team to get the most recent, approved Blockify datasets. These will likely be provided as one or more .jsonl files (JSON Lines format) or similar structured data files.
Organize Datasets: Place all the dataset files you intend to deploy into a single, clean folder. For example: C:\AirgapAIDatasetUpdate\Datasets\
Consider Versioning: It's a best practice to name your dataset files or the containing folder with a version number (e.g., CIA_World_Factbook_US_v2.jsonl or Iternal_Technologies_Portfolio_Q3_2024\) to help track updates and facilitate potential rollbacks.
Calculate Checksums: For each dataset file, calculate a cryptographic checksum (e.g., Secure Hash Algorithm 256, often abbreviated as SHA-256). This hash value is a unique digital fingerprint of the file. You'll use this later to verify that the files were transferred correctly and haven't been tampered with.
- How to Calculate SHA-256 (Windows PowerShell): Open PowerShell and navigate to the folder containing your dataset file. Get-FileHash -Algorithm SHA256 "your_dataset_file.jsonl" Record the output hash value.

3. Creating the Microsoft Intune Application Package

Microsoft Intune, a cloud-based service in Microsoft Endpoint Manager, allows Information Technology administrators to manage devices and applications. For AirgapAI dataset updates, you will create a Line-of-Business application within Intune to distribute your Blockify datasets.

What is Microsoft Intune?

Microsoft Intune is a unified endpoint management solution that helps organizations manage the devices their employees use (laptops, phones, tablets) and the applications running on those devices. It provides capabilities for deployment, configuration, security policy enforcement, and application updates. For AirgapAI, Intune is ideal for pushing dataset files to local user directories without requiring cloud access for the Artificial Intelligence itself.

Steps to Create the Intune Application

Prepare the Source Folder:

Create a dedicated folder for your Intune package. For example: C:\IntuneAirgapAIDataset_v1.0\
Inside this folder, place all the Blockify dataset files you organized in Section 2.
Crucially, also include a simple batch script or PowerShell script that will handle the actual file copy operation. This script will copy the new dataset files to the AirgapAI CorpusRepo folder on the end-user's device.

Example PowerShell Script (Deploy-AirgapAIDatasets.ps1):

# Script to deploy AirgapAI Blockify datasets
# This script should be run in the user context to target %AppData%

$SourcePath = "$PSScriptRoot\Datasets" # Assuming datasets are in a subfolder named 'Datasets'
$DestinationPath = "$env:APPDATA\airgap-ai-chat\CorpusRepo"

Write-Host "Starting AirgapAI Dataset Deployment..."
Write-Host "Source: $SourcePath"
Write-Host "Destination: $DestinationPath"

if (-not (Test-Path $SourcePath)) {
    Write-Error "Source path not found: $SourcePath"
    exit 1
}

if (-not (Test-Path $DestinationPath)) {
    New-Item -Path $DestinationPath -ItemType Directory -Force
    Write-Host "Created destination path: $DestinationPath"
}

try {
    Copy-Item -Path "$SourcePath\*.jsonl" -Destination $DestinationPath -Recurse -Force
    Write-Host "Successfully copied all .jsonl files to $DestinationPath"

    # Optional: Log the update
    $LogFile = "$env:TEMP\AirgapAIDatasetUpdate.log"
    "$(Get-Date) - AirgapAI Datasets updated to version [Your_Dataset_Version]" | Out-File $LogFile -Append
}
catch {
    Write-Error "Failed to copy files: $($_.Exception.Message)"
    exit 1
}

Write-Host "AirgapAI Dataset Deployment Completed."
exit 0

Make sure to put your actual .jsonl files in a Datasets subfolder within the Intune package folder, or adjust the $SourcePath variable in the script accordingly.

Package the Content with the Microsoft Win32 Content Prep Tool:
- Download the Microsoft Win32 Content Prep Tool (often abbreviated as IntuneWinAppUtil.exe) from Microsoft's GitHub repository.
- Open a command prompt or PowerShell and navigate to where you saved IntuneWinAppUtil.exe.
- Run the tool: IntuneWinAppUtil.exe
- It will prompt you for:
  - Source Folder: The full path to your C:\IntuneAirgapAIDataset_v1.0\ folder.
  - Setup File: The name of your PowerShell script (e.g., Deploy-AirgapAIDatasets.ps1). This is the file Intune will execute first.
  - Output Folder: A path where the .intunewin package file will be created (e.g., C:\IntunePackages\).
  - Do you want to specify catalog folder? Type N (No).
- This process will create a single .intunewin file, which is a compressed and encrypted package ready for upload to Intune.
Upload the .intunewin File to Microsoft Intune:
- Sign in to the Microsoft Endpoint Manager admin center.
- Navigate to Apps > All apps > Add.
- Select Windows app (Win32) as the app type.
- Click Select app package file and browse to upload your .intunewin file.
- Click OK.
Configure Application Information:
- App information: Fill in details like Name (e.g., "AirgapAI Blockify Datasets Q3 2024"), Description, Publisher (Iternal Technologies), and Version. Upload an icon for better user experience, if desired.
- Program:
  - Install command: powershell.exe -ExecutionPolicy Bypass -File "Deploy-AirgapAIDatasets.ps1"
  - Uninstall command: (Optional, as dataset updates usually overwrite. If you need to revert, you'd deploy an older version or a cleanup script.)
  - Install behavior: Select User (this is crucial to ensure the script runs in the user's context and targets the AppData folder correctly).
  - Device restart behavior: No specific action
- Requirements:
  - Operating system architecture: Select 64-bit.
  - Minimum operating system: Windows 10 1607 (or your organization's baseline).
  - Disk space required: Enter an estimate for your dataset files (e.g., 500 MB).
  - Physical memory required: (Optional, generally not critical for dataset copy).
  - Minimum logical processors: (Optional).
  - Minimum CPU speed: (Optional).
- Detection rules: This tells Intune if the app (datasets) is already installed.
  - Select Manually configure detection rules.
  - Add a rule:
    - Rule format: File
    - Path: %APPDATA%\airgap-ai-chat\CorpusRepo
    - File or folder: The name of one of your .jsonl dataset files (e.g., CIA_World_Factbook_US_v2.jsonl).
    - Detection method: File or folder exists (or if you want to be more precise, String (version) with the version you've embedded in the file content, if applicable).
    - Associated with a 32-bit app on 64-bit clients: No
- Dependencies: (Not usually needed for simple dataset updates).
- Supersedence: (Not usually needed for simple dataset updates; typically for replacing full applications).

4. Deploying, Scheduling, and Verifying Dataset Updates

Once your application package is ready in Microsoft Intune, the next step is to deploy it to your target users, manage the update schedule, and ensure the deployment was successful.

Assigning the Dataset Update Package

Go to Assignments: In the Microsoft Endpoint Manager admin center, after configuring your application, navigate to the Assignments section.
Add Groups:
- Click Add group.
- For Assignment type, choose Required. This ensures the datasets are pushed to all targeted users.
- Click Add groups and select the Azure Active Directory (soon to be Microsoft Entra ID) user groups or device groups that need the AirgapAI dataset updates. For instance, you might target a "AirgapAI Users" group or a "Dell AI PC Fleet" device group.
- Review and apply the assignment.

Scheduling Updates and Rollout Plans

Cadence: AirgapAI dataset updates are typically pushed whenever new information is Blockified and approved by your data governance team. This could be monthly, quarterly, or on an ad-hoc basis for critical updates.
Gradual Rollout (Pilot Groups): For larger organizations, it's highly recommended to deploy updates to a small pilot group first.
- Create a pilot Azure Active Directory group (e.g., "AirgapAI Pilot Users").
- Assign the update package as Required to this pilot group initially.
- Monitor feedback and success within the pilot group for a few days before expanding the deployment.
Full Deployment: Once validated, modify the assignment to include your broader user groups.

Verifying Deployment Success and Integrity

Microsoft Intune Reporting:
- In the Microsoft Endpoint Manager admin center, navigate to Apps > All apps.
- Select your "AirgapAI Blockify Datasets" application.
- Review the Device install status and User install status reports. This will show you which devices and users successfully received the update, which are pending, and any failures.
- Investigate any failures by checking device logs or error codes provided by Intune.
Local Device Verification (Spot Checks):
- Log in to a few targeted user devices.
- Navigate to the CorpusRepo path: C:\Users\[Username]\AppData\Roaming\airgap-ai-chat\CorpusRepo
- Confirm file existence: Ensure the new .jsonl dataset files are present.
- Confirm file size and modification date: Verify that the files match the expected size and have a recent modification timestamp, indicating they were newly copied.
- Verify checksums: Use the Get-FileHash -Algorithm SHA256 "your_dataset_file.jsonl" PowerShell command on the deployed file and compare the resulting hash value with the checksum you recorded during your packaging phase. This ensures the file was transferred without corruption or alteration.
User Feedback: Encourage users to report any unexpected behavior from AirgapAI after the update, though with dataset updates, issues are rare if the data was Blockified correctly.

5. Establishing Rollback Plans and Change Management

Even with the most meticulous planning, issues can arise. Having a clear rollback plan and a robust change management process is critical for maintaining system stability and user trust.

Why Rollback Plans are Essential

A rollback plan outlines the steps to revert a system to a previous, stable state if a new deployment causes unforeseen problems. For AirgapAI dataset updates, potential issues could include:

Corrupted Data: Though rare with checksum verification, a dataset file could become corrupted during distribution or on the device.
Incorrect Data: An incorrect or unapproved version of a dataset might have been deployed.
Performance Degradation: While unlikely with datasets, an issue could theoretically arise.

Steps for a Dataset Rollback

Identify the Problem: Clearly define what issue is occurring and link it to the recent dataset update.
Prepare the Previous Version: Ensure you have access to the previous, stable version of your Blockify dataset package (.intunewin file) in your Intune environment. This highlights the importance of versioning your packages.
Create a Rollback Deployment:
- If the previous version is not yet in Intune, upload it as a new Win32 app (e.g., "AirgapAI Blockify Datasets Q2 2024 - Rollback").
- Create an installation script that copies the older dataset files to the CorpusRepo path.
- Assign this rollback package as Required to the affected user group(s), potentially targeting a higher priority or earlier installation time than the problematic update.
Remove the Problematic Deployment: Once the rollback is successfully initiated, remove the assignment for the problematic dataset update package to prevent it from redeploying.
Communicate: Inform affected users about the rollback and the expected return to normal functionality.
Post-Mortem Analysis: After the rollback, conduct an investigation to understand why the issue occurred, preventing its recurrence in future deployments.

Change Management Checklist for AirgapAI Dataset Updates

A formal change management process ensures that all deployments are thoroughly reviewed, tested, and documented.

Pre-Deployment:
- Dataset Validation: Confirm Blockify dataset (e.g., .jsonl file) is the correct version and has passed internal quality checks.
- Checksums: Generate and record SHA-256 checksums for all new dataset files.
- Script Review: Verify the PowerShell or batch script for deployment (e.g., Deploy-AirgapAIDatasets.ps1) is accurate and targets the correct path (%APPDATA%\airgap-ai-chat\CorpusRepo).
- Intune Package Creation: Successfully create the .intunewin package using the Microsoft Win32 Content Prep Tool.
- Intune Configuration: Ensure the Win32 app in Intune has correct settings:
  - Install command and install behavior (User).
  - Detection rules (path to new dataset file).
  - Descriptive name and version.
- Rollback Plan: Identify the previous stable dataset package and its Intune application.
- Communication Plan: Draft communications for users (if necessary).
Deployment:
- Pilot Group Deployment: Assign the update to a small pilot group for initial testing.
- Monitor Pilot: Closely monitor Microsoft Intune reports and gather feedback from pilot users.
- Full Rollout: If pilot is successful, expand the assignment to the main user groups.
- Monitor Full Deployment: Continue monitoring Intune reports for successful installations and any errors.
Post-Deployment:
- Verification: Perform local spot checks on user devices to confirm file presence, size, and checksums.
- AirgapAI Testing: (Optional, but recommended for critical datasets) Have a few users test AirgapAI's responses using the updated datasets.
- Documentation: Update internal documentation with the new dataset version and deployment details.
- Archiving: Retain the .intunewin package and source files for the deployed version for future reference or rollback needs.

6. Troubleshooting and Best Practices

Even with clear instructions, issues can sometimes arise. Here are common troubleshooting tips and best practices for managing AirgapAI dataset updates with Microsoft Intune.

Common Troubleshooting Scenarios

Intune Reports "Failed" or "Error":
- Check the script: The most common cause is an error in the PowerShell or batch script. Review Deploy-AirgapAIDatasets.ps1 for typos, incorrect paths, or permission issues.
- Logs on the device: On the affected device, look for Intune Management Extension (IME) logs. These are typically in C:\ProgramData\Microsoft\IntuneManagementExtension\Logs. The AgentExecutor.log or IntuneManagementExtension.log can provide details on why the script failed.
- User Context: Ensure the app's Install behavior in Intune is set to User. If it runs in System context, it won't be able to write to C:\Users\[Username]\AppData\Roaming\.
- Detection Rules: Verify your detection rules are accurate. If Intune thinks the dataset is already present (incorrectly), it won't attempt to install.
- Source File Issues: Double-check that the .intunewin package contains all necessary files (script, datasets) and that the paths within the script are relative to the package's root.
Datasets Not Appearing in AirgapAI:
- Correct Path: Confirm the datasets were copied to the exact CorpusRepo path: C:\Users\[Username]\AppData\Roaming\airgap-ai-chat\CorpusRepo. Even a minor typo will prevent AirgapAI from finding them.
- File Format: Ensure the dataset files are in the expected .jsonl format that AirgapAI anticipates.
- AirgapAI Restart: Advise users to restart the AirgapAI application after updates, as it may need to re-read its data directory.
Slow Deployment:
- Network Bandwidth: If deploying large datasets to many devices simultaneously, network bandwidth could be a bottleneck. Intune allows for staggered deployments, which can help.
- Device Status: Ensure devices are online and actively communicating with Intune.
Checksum Mismatch:
- Re-package and Re-deploy: If a file on a device has a different checksum than expected, the file might be corrupted. Re-package the .intunewin file and re-deploy.
- Source File Integrity: Double-check the integrity of your source dataset files before packaging.

Best Practices for Information Technology Administrators

Version Control: Always use clear versioning for your Blockify datasets and your Intune application packages. This makes rollbacks and troubleshooting significantly easier.
Test Thoroughly: Always deploy to a small pilot group before a broad rollout. Test on different hardware configurations if your fleet is diverse.
Documentation: Maintain detailed records of each dataset version, its checksums, and the corresponding Intune deployment package.
Automate Checksums: Consider enhancing your deployment script to perform a checksum verification after copying files, and log the results. This provides immediate feedback on file integrity.
Communicate Clearly: For significant updates or during troubleshooting, provide clear communication to end-users about what is happening and what they can expect.
Leverage Iternal Support: Do not hesitate to contact Iternal Technologies' support team at support@iternal.ai for any specific AirgapAI-related deployment questions.
Security First: Remember that the primary advantage of AirgapAI is its local, secure operation. Ensure your deployment methods uphold this principle by avoiding any unintended exposure of data.
Regular Review: Periodically review your dataset update process, scripts, and Intune configurations to ensure they remain efficient and secure.

7. Conclusion: Secure, Efficient Artificial Intelligence with AirgapAI and Intune

You are now equipped to become the Information Technology administrator who champions efficient and secure Artificial Intelligence deployment across your organization. By leveraging the power of Microsoft Intune with Iternal Technologies' AirgapAI and its patented Blockify technology, you can ensure your workforce benefits from highly accurate, confidential Artificial Intelligence capabilities without compromising data sovereignty or incurring excessive costs.

This guide has walked you through the intricate details of packaging, deploying, scheduling, and verifying dataset updates, all while keeping your organization's sensitive data precisely where it belongs: offline and under your complete control. Embrace this workflow to deliver consistent, trusted Artificial Intelligence experiences across your fleet, solidifying your reputation as an innovative and security-conscious leader.

Unlock the full potential of secure, on-device Artificial Intelligence for your enterprise.

Download the free trial of AirgapAI today at: https://iternal.ai/airgapai