Set up and operate OpenMindAI with confidence.

OpenMindAI Documentation

• OpenMindAI is a local-first AI platform for desktop and mobile devices. It combines local AI chat, reasoning, model management, document workflows, coding assistance, project workspaces, multimodal features, local storage, optional connected services, and maintenance tools in one product family.
• This documentation covers both OpenMindAI Desktop and OpenMindAI Mobile. Some capabilities are platform-specific because desktop and mobile operating systems have different hardware, storage, permission, packaging, and runtime constraints.
• OpenMindAI is designed so core AI inference can run on the user device after the required local model and runtime are installed. Features that need current public information, downloads, account connections, or external services still require internet access.
• Website: https://openmindai.vercel.app/
• Contact and support: https://openmindai.vercel.app/contact
• Users should always download OpenMindAI from an official distribution channel and review operating-system security prompts before installation.

What OpenMindAI Provides

• Local AI chat for supported text models.
• Thinking and reasoning workflows for models that support deeper reasoning behavior.
• Local model discovery, installation, verification, activation, update checking, cancellation, and deletion.
• Local conversation history and settings stored on the device.
• Document and file workflows for supported text, PDF, DOCX, Markdown, source-code, JSON, YAML, CSV, and related formats.
• Image and vision workflows where a compatible multimodal model is installed.
• Voice input and audio-related workflows where supported by the platform.
• Generated artifacts such as text, Markdown, code, PDF, DOCX, images, audio, and other supported local outputs.
• Desktop project workspaces that can be attached to real folders.
• Desktop Project Agent workflows that can inspect and modify files inside approved project boundaries.
• Optional connected applications and services for workflows that intentionally require external accounts or remote data.
• Portable or secondary-drive storage support on desktop for large model collections and application data.
• Hardware-aware local inference so different devices can use suitable models and runtime settings.

Local First Design

• Local-first means OpenMindAI prefers device-side processing for core AI tasks when the required local model and runtime are available.
• Normal local inference does not need to send every prompt to a remote AI service.
• Local chat history can remain on the user device.
• Downloaded model files remain local unless the user intentionally copies, moves, backs up, or shares them.
• Local-first does not mean the application never uses a network connection.
• Model downloads, application updates, web search, research retrieval, connected services, and some support or store functions require internet access.
• Users should distinguish a local model session from an online integration before entering confidential or regulated information.
• Local processing reduces remote exposure but does not eliminate risks from malware, compromised operating systems, stolen devices, weak account security, malicious files, unsafe commands, or unauthorized physical access.

Supported Platforms

• OpenMindAI Desktop is designed for supported Windows, Linux, and macOS environments.
• Windows is the primary packaged desktop distribution path.
• Linux and macOS support depends on the availability of compatible application builds, native dependencies, runtime support, and hardware coverage.
• OpenMindAI Mobile is built for Android and iOS.
• Mobile features are adapted for tighter memory, battery, storage, thermal, background-execution, and permission limits.
• Feature availability can differ between operating systems and hardware generations.
• Users should keep their operating system, graphics drivers, security updates, and application build reasonably current.

Desktop Installation Overview

• Use an official OpenMindAI installer, an approved application-store listing, or the official bootstrap path when available.
• Do not install modified copies from unknown mirrors, unofficial download portals, random file-sharing sites, or unverified links.
• Before installation, verify that the computer has enough storage for the application and the local AI models you plan to use.
• AI model files can be much larger than the application itself and may require hundreds of megabytes or several gigabytes per model.
• On Windows, the normal packaged installation uses the OpenMindAI setup executable.
• OpenMindAI can also provide a Windows bootstrap setup that prepares the application from official project resources.
• Linux and macOS bootstrap paths can prepare supported environments where a compatible packaged release is not the preferred path.
• After installation, launch OpenMindAI and complete first-run storage, hardware, runtime, and model setup.

Install OpenMindAI on Windows

• Download OpenMindAI from the official release source, Microsoft Store listing when available, or another official OpenMindAI distribution channel.
• Open the downloaded Windows installer.
• Review the publisher, filename, source, and Windows security information before approving installation.
• Follow the installer prompts and complete the application installation.
• Launch OpenMindAI from the Start menu, desktop shortcut if created, or installed application list.
• On first launch, choose the storage location for OpenMindAI AI data when the application asks for it.
• Allow OpenMindAI to inspect available CPU, memory, graphics hardware, and storage so it can prepare a suitable local runtime plan.
• Choose or install a supported local model.
• Wait for the model download and verification to finish before starting local inference.
• After the required runtime and model are ready, open Chat and send a simple test prompt.
• If Windows displays a firewall or security prompt, approve only the access required for the feature you intend to use and only when the application came from an official source.
• If installation fails, restart Windows, confirm sufficient disk space, confirm Windows is updated, check security software logs, and try the official installer again.

Windows Bootstrap Setup

• OpenMindAI provides a Windows bootstrap path for supported installation and developer-oriented setup workflows.
• The bootstrap process can obtain official project resources and prepare the application when a compatible packaged path is not being used.
• Run the official OpenMindAI setup batch file only after confirming that it came from the official OpenMindAI release or repository source.
• The bootstrap validates that the source directory resembles a real OpenMindAI repository before continuing with source-build fallback behavior.
• The bootstrap can use the installed Windows development environment when a source build is required.
• Source-build fallback requires Node.js, npm, Rust, the Microsoft C++ toolchain, and the platform dependencies required by Tauri.
• End users who do not need source builds should prefer the normal signed packaged installer or an approved application-store listing.

Install OpenMindAI on Linux

• Use the official Linux distribution method provided by OpenMindAI for your supported architecture.
• A shell bootstrap may be available for supported Linux systems.
• Before running a bootstrap script, inspect the source, verify that it came from the official OpenMindAI project, and make sure your package manager and system are up to date.
• Linux desktop builds require the native WebKitGTK and AppIndicator dependencies expected by Tauri.
• Development and source-build environments also require Node.js, npm, Rust, a C or C++ build toolchain, and the platform libraries needed by the local AI runtime.
• Hardware acceleration depends on available Linux drivers, compatible graphics hardware, and runtime support.
• CPU execution remains an important fallback when GPU acceleration is unavailable.
• After installation, launch OpenMindAI, select a local data root, prepare a compatible runtime, download a model, and test local chat.
• Linux ARM64 availability can differ from x64 support, so users should confirm that their architecture is supported before installation.

Install OpenMindAI on macOS

• Use the official macOS distribution or command-bootstrap path provided by OpenMindAI when available for your system.
• macOS security may require the user to approve a downloaded application according to Gatekeeper and system security settings.
• Only approve an OpenMindAI build when its origin is trusted and verified.
• Apple Silicon and Intel systems can have different runtime and dependency requirements.
• Local inference performance depends on available unified memory, CPU and GPU capabilities, model size, quantization, and runtime support.
• For development builds, install Node.js, npm, Rust, Xcode Command Line Tools, and the dependencies required by Tauri and the selected local model runtime.
• After installation, complete the same first-run process used by other desktop platforms: storage selection, hardware detection, runtime preparation, model installation, verification, and chat testing.

Desktop First Run

• The first-run process prepares a local AI environment instead of requiring a paid cloud AI account.
• Choose where OpenMindAI AI data should live.
• Create or confirm the local profile used by the application.
• OpenMindAI detects available hardware to help select appropriate runtime and model settings.
• The required local runtime is prepared or installed.
• Choose a recommended model or open the Model Manager to select another compatible model.
• Start the model download and keep the device powered and connected until large downloads complete.
• OpenMindAI verifies downloaded model files before treating them as ready when verification data is available.
• After preparation is complete, OpenMindAI opens the main desktop workspace.
• Future launches should open the prepared local environment directly unless storage is unavailable, configuration is reset, or required runtime files are missing.

Choosing Desktop Storage

• OpenMindAI separates the installed desktop application from large AI data so users can choose a practical storage location.
• The selected desktop data root can hold model files, AI runtimes, the local database, cache, logs, generated artifacts, workspaces, knowledge data, and backups.
• Users with limited system-drive space can place OpenMindAI AI data on a secondary internal drive or a suitable external SSD.
• Fast SSD storage is recommended for large local models because model loading can involve reading several gigabytes.
• Avoid unreliable removable storage for critical data unless you maintain backups.
• If an external drive containing OpenMindAI data is disconnected, reconnect the drive before starting workflows that depend on its models or history.
• OpenMindAI should report an unavailable configured storage location instead of silently pretending the user has a new empty installation.
• Do not manually move active model and database directories while OpenMindAI is running.
• Use application-supported storage management or close the application before performing carefully planned manual migration.
• Keep additional free space for temporary downloads, updates, model verification, generated documents, backups, and operating-system needs.

Portable Desktop Storage

• OpenMindAI supports portable-storage workflows so large AI assets can live independently of the main operating-system installation.
• Portable mode can resolve the application data location relative to a portable root when the expected marker configuration is present.
• This design helps users move a prepared environment between compatible locations without depending on a permanently fixed drive letter.
• A portable OpenMindAI environment can include model files, runtimes, local data, artifacts, workspaces, and related resources.
• Users should safely eject external storage after OpenMindAI is fully closed.
• Do not disconnect a drive while a model is loading, downloading, being verified, or actively used.
• Portable storage should use a filesystem and device that can reliably handle multi-gigabyte files.
• Maintain a backup of irreplaceable conversations, project files, generated artifacts, and configuration even when using portable storage.

Desktop Model Setup

• Open Model Manager after first-run setup or from the main application navigation.
• Review available OpenMindAI model names and the capabilities associated with each model.
• Choose a model appropriate for your available RAM, VRAM, storage, and intended task.
• Start the model download.
• Watch the download progress and allow the transfer to complete.
• Pause or cancel the download when those controls are available.
• Do not treat a partial model file as ready for inference.
• OpenMindAI validates or verifies a model before activation when the model source provides verification information.
• After verification, activate the model for a conversation or allow automatic routing to choose a compatible installed model.
• Delete unused models through Model Manager to reclaim storage.
• Removed models can be downloaded again later if they remain available and compatible.

Desktop Default Local Model

• OpenMindAI Desktop uses a lightweight quantized local language model as the baseline recommended setup.
• The baseline desktop model is based on the Qwen3 4B family with Q4 class quantization.
• The user-facing application can present OpenMindAI model names rather than exposing raw upstream repository names in normal workflows.
• Model weights are not stored in the normal source repository because they are very large.
• Models are downloaded separately into the selected OpenMindAI data root.
• Actual model performance depends on CPU, GPU, RAM, VRAM, memory bandwidth, runtime backend, context length, operating-system drivers, and other running applications.

Desktop Hardware Detection

• OpenMindAI detects processor information, available memory, and graphics hardware to prepare suitable local inference behavior.
• Hardware detection does not guarantee that every model will run on every device.
• Smaller quantized models are more appropriate for systems with limited memory.
• Larger models can provide stronger capability for some tasks but need more memory and may generate more slowly.
• GPU acceleration can improve performance when a compatible backend and driver are available.
• CPU execution remains a fallback path for compatible local models.
• Long context windows increase memory use and processing time.
• High system load, thermal throttling, antivirus scanning, slow disks, or background applications can reduce generation speed.

Desktop Chat

• Open Chat from the main desktop workspace.
• Select an installed model or use the application's supported automatic routing behavior.
• Enter a prompt and send the message.
• OpenMindAI streams the local model response while generation is in progress.
• Use Stop when you want to cancel an active generation.
• Use Regenerate when you want another answer from the same or revised context.
• Edit previous messages where the interface supports message editing.
• Attach supported files when you want the model to use document or code context.
• Use separate conversations for unrelated tasks when doing so improves context quality.
• Delete conversations that are no longer needed through the available history controls.
• Local conversation history is stored in the application data environment rather than requiring a cloud chat account for core desktop use.

Thinking and Reasoning

• Use a thinking or reasoning mode when the selected model and workflow support deeper multi-step analysis.
• Reasoning modes can be slower than normal chat because the model may perform more internal processing.
• Use reasoning for complex debugging, planning, architecture, research organization, difficult mathematics, and other tasks that benefit from additional analysis.
• Reasoning does not guarantee correctness.
• Verify important technical, scientific, financial, medical, legal, academic, or safety-related conclusions with reliable external evidence or qualified professionals.
• Long reasoning sessions can require more memory and context than short chat requests.

Web Search and Research

• Web Search and Research are network-dependent features and are separate from fully offline local inference.
• Use Web Search when the answer depends on current public information.
• Use Research for broader evidence-gathering workflows when supported.
• Retrieved web content should be treated as untrusted data rather than trusted executable instruction.
• Prompt injection can exist inside websites and retrieved documents.
• OpenMindAI should keep external evidence separate from system and user intent when constructing research context.
• Users should verify important web-derived claims against the original sources.
• A network failure should not prevent already-prepared local chat and local project functionality from continuing.

Desktop Projects

• Projects provide a persistent workspace for related conversations, instructions, context files, and real local folders.
• Create a Project when you want OpenMindAI to maintain a focused context around one codebase, research task, website, document collection, or other ongoing work.
• A Project can include project instructions.
• A Project can link conversations.
• A Project can include reference files.
• A Project can attach a local folder as a working directory.
• A Project can provide a file browser and text editor for supported files.
• A Project can provide a Work surface for active tasks.
• A Project can link a Project Agent conversation.
• Use one Project per clearly separated body of work when isolation and context control are important.

Open Folder as Project

• Desktop users can attach an existing local folder to an OpenMindAI Project.
• Use this for existing source repositories, websites, research code, scripts, documents, and other real working directories.
• OpenMindAI keeps normal workspace access scoped to the attached project folder unless broader access is explicitly approved.
• Review the selected directory carefully before granting AI-assisted file access.
• Do not attach folders containing secrets, credentials, personal archives, or unrelated confidential material unless you understand and accept the access scope.
• Maintain Git history or independent backups before allowing automated modification of important projects.

Desktop Project Agent

• The Project Agent can work with an attached project folder using the configured local OpenMindAI model and runtime.
• The agent can inspect directories and files.
• The agent can read source code and text content.
• The agent can create and modify scoped files.
• The agent can rename or delete scoped files when the requested task requires it and applicable approval checks permit the action.
• The agent can use recent project conversation context.
• The agent can refresh project context after file changes.
• The agent can observe failed commands and timeouts.
• The agent can reason over failures and attempt repairs.
• The agent can run applicable validation before reporting that a task is complete.
• The agent can inspect Git status and diff information when the required terminal permission boundary is enabled.
• Agentic actions can still make mistakes, so users should review diffs, run tests, and keep version-control or backup protection.

Full PC and Terminal Permission

• Ordinary chat does not automatically require unrestricted filesystem or terminal access.
• Attached project folders provide a narrower workspace boundary.
• Broader Full PC and Terminal capability must be explicitly approved through the application permission path before the Project Agent can use that access.
• Grant broader access only when the task genuinely requires it.
• Use least privilege whenever possible.
• Review shell commands, file mutations, Git changes, package installation, and destructive operations carefully.
• OpenMindAI uses bounded execution controls such as timeouts, output limits, duplicate-action protection, failure budgets, and validation requirements to reduce runaway agent behavior.
• No safety boundary can guarantee that every generated command is correct.
• Never allow an AI workflow to handle production credentials, private keys, recovery codes, or sensitive secrets without a carefully designed secure process.

Connected Apps

• Connected Apps are optional and extend OpenMindAI beyond local-only workflows.
• Connected services do not replace the local AI model architecture.
• Desktop connection families can include Google Workspace, GitHub, Microsoft 365, Slack, Notion, Dropbox, and MCP servers where supported.
• Manage connections from the application settings area.
• Grant only the permissions needed for the workflow you intend to use.
• OAuth tokens, connection secrets, and account credentials should not be written into normal chat history.
• Remote actions that modify external data should remain subject to provider authorization and OpenMindAI approval controls.
• Third-party services have their own terms, privacy policies, availability, rate limits, security practices, and possible costs.
• Disconnect an integration when you no longer want OpenMindAI to use the granted authorization.

Artifacts and Generated Files

• OpenMindAI can create and track local artifacts associated with supported conversations and workflows.
• Supported artifact types can include plain text.
• Supported artifact types can include Markdown.
• Supported artifact types can include source-code files.
• Supported artifact types can include PDF documents.
• Supported artifact types can include DOCX documents.
• Supported artifact types can include images.
• Supported artifact types can include video where the required local workflow is available.
• Supported artifact types can include voice and audio where compatible local tooling is available.
• Generated files should be reviewed before publication, submission, deployment, printing, or distribution.
• Keep backups before replacing important existing documents with generated or edited versions.
• AI-generated text, code, images, and documents can contain factual, formatting, licensing, security, or structural errors.

Desktop Document Workflows

• Attach a supported document when you want OpenMindAI to summarize, explain, extract, rewrite, classify, or use it as context.
• PDF processing depends on whether the file contains machine-readable text or requires image extraction.
• DOCX documents can be used for supported document workflows.
• Markdown and plain-text files are well suited to local context processing.
• Source-code files can be attached for coding assistance.
• JSON, YAML, CSV, and related text formats can be used when the current model context can handle the content size.
• Very large documents may need to be processed in sections.
• Password-protected or encrypted documents require appropriate user authorization and compatible parsing support.
• Review extracted text from scanned images because OCR and multimodal extraction can make mistakes.
• Do not assume that complex document conversion will preserve every font, table, page break, image placement, or layout detail.

Desktop Maintenance

• Use maintenance and diagnostic tools when runtime, model, storage, or application behavior becomes inconsistent.
• Check storage availability before diagnosing missing models or missing history.
• Confirm that the configured model files still exist.
• Confirm that the selected runtime is installed and healthy.
• Restart the local runtime if a model remains unavailable after a transient failure.
• Use built-in repair or verification workflows where available.
• Review diagnostic information before deleting user data.
• Back up important local information before major repair, migration, or reset actions.
• Keep application updates and security fixes reasonably current.

Desktop Backup

• Back up important generated documents and user project files independently of the application.
• Back up local OpenMindAI data when conversation history or configuration is important to you.
• Large model files can often be downloaded again, so users may choose not to include all models in every backup.
• Backing up models can still save significant time and bandwidth.
• Protect backups that contain private conversations, documents, source code, or credentials.
• Test restoration procedures before relying on a backup strategy for critical work.
• Do not treat a single external drive as both the working copy and the only backup.

Desktop Uninstallation

• On Windows, remove OpenMindAI through Installed Apps, Apps and Features, the application uninstaller, or the relevant store uninstall workflow.
• On Linux, remove the application using the installation method appropriate to the package or bootstrap path used.
• On macOS, remove the installed application according to the distribution method and macOS application-management rules.
• Uninstalling the main desktop application may not remove large model files or user-selected external data directories.
• Before manually deleting remaining OpenMindAI data, confirm that you no longer need conversation history, settings, artifacts, workspaces, backups, or downloaded models.
• Generated files saved outside OpenMindAI directories remain where you saved them until you delete them.
• Use secure deletion or encrypted storage practices when local content contains sensitive information and your risk model requires stronger data disposal.

Mobile Application Overview

• OpenMindAI Mobile is a Flutter application for Android and iOS.
• The mobile application is maintained independently from the React and Tauri desktop codebase.
• Mobile AI inference is designed to run locally on the device for supported models.
• Normal mobile chat history is stored locally.
• Voice transcription can run locally through the supported Whisper workflow.
• Document processing and supported vision input can run on the device.
• OpenMindAI Canvas uses local vector synthesis rather than silently switching to a paid cloud image API.
• Search and Research modes require a network connection because they retrieve current public web evidence.
• Firebase Analytics is used for app-level usage analytics in the current mobile design.
• OpenMindAI does not use its Firebase service to send prompts, responses, attachments, local model files, or normal chat history for AI inference.

Install OpenMindAI Mobile on Android

• Install the official OpenMindAI Android application from an approved application store or official distribution source when available.
• Do not install modified APK files from unknown websites.
• Confirm that the device has enough free storage for the application, the first-run model, attachments, history, and any larger optional models you plan to install.
• Launch OpenMindAI after installation.
• Review the welcome and capability information.
• Review requested permissions and approve only the capabilities you want to use.
• Read and accept the OpenMindAI license and application terms presented during onboarding.
• Allow the application to inspect device memory and storage so it can prepare an appropriate local model setup.
• The first-run lightweight model is downloaded to app-private storage.
• Wait for the model download and verification to complete.
• Open Chat and send a simple prompt to confirm that local inference works.
• Install larger optional models later from Model Manager instead of downloading the entire catalog during installation.

Install OpenMindAI Mobile on iOS

• Install the official OpenMindAI iOS application from the approved App Store distribution path when available.
• Launch OpenMindAI and complete the welcome flow.
• Review camera, microphone, photo-library, and notification permissions when the application requests them for relevant features.
• Read and accept the application terms and license during onboarding.
• Allow OpenMindAI to inspect available memory and storage for appropriate local model selection.
• Download the lightweight first-run local model.
• Wait for verification and initialization to complete.
• Open Chat and test local inference.
• Install larger models only when you need them and when the device has enough available storage and memory.
• iOS may suspend or terminate memory-intensive background tasks, so keep the application active during large setup operations when practical.

Mobile First Run

• The first mobile launch begins with welcome and capability information.
• The application presents local-AI usage instructions.
• The user reviews and accepts the OpenMindAI license during onboarding.
• OpenMindAI checks device memory and available storage.
• OpenMindAI downloads the lightweight OpenMindAI Nano model to app-private storage.
• The first-run model is approximately 429 MB, although actual downloaded and installed footprint can vary with packaging and metadata.
• The application verifies the model when upstream integrity metadata is available.
• After setup completes, OpenMindAI opens Chat.
• Later launches open the main application directly because onboarding completion is stored locally.
• OpenMindAI intentionally avoids downloading several gigabytes of models just because a device has high memory.

Mobile Model Catalog

• OpenMindAI Nano is the default lightweight first-run mobile model and is approximately 0.43 GB.
• OpenMindAI Swift is an optional local model and is approximately 1.28 GB.
• OpenMindAI Core is an optional local model and is approximately 2.50 GB.
• OpenMindAI Titan is an optional larger local model and is approximately 5.20 GB.
• OpenMindAI Reasoning Mini is an optional reasoning-oriented model and is approximately 1.12 GB.
• OpenMindAI Reasoning is an optional larger reasoning-oriented model and is approximately 4.68 GB.
• OpenMindAI Lens is an optional vision model and is approximately 2.78 GB plus its multimodal projector.
• Model sizes are approximate and can change when upstream files or packaging are updated.
• Models are not bundled into the main mobile application package.
• Optional models are downloaded only when the user chooses to install them.
• Downloaded models can be removed independently without uninstalling the application.
• User-facing OpenMindAI model names hide unnecessary raw upstream repository and filename details in normal application screens.

Mobile Model Download

• Open Model Manager from the mobile application.
• Choose the model you want to install.
• Review the approximate download size and device storage before starting.
• Start the download over a reliable Wi-Fi connection when the model is large.
• OpenMindAI stores model files in application-private storage.
• Model downloads support cancellation.
• Supported download behavior can resume interrupted transfers.
• OpenMindAI can verify a model with SHA-256 when the upstream source provides compatible digest information.
• Do not close the application repeatedly during first-run provisioning if the operating system is aggressively suspending background work.
• Delete optional models that you no longer use to reclaim storage.
• Large model downloads can consume substantial mobile data, so users with limited data plans should use Wi-Fi.

Mobile Chat

• Open Chat after onboarding is complete.
• Use the installed OpenMindAI model appropriate for the task.
• Send text prompts normally.
• Responses are streamed from the local model session.
• Use Stop to cancel an active generation.
• Use Regenerate to create another response.
• Conversation history is stored in a local SQLite database.
• Existing mobile history can migrate from earlier local storage formats when the application performs its supported migration.
• Users can search conversations where the current interface provides search.
• Users can rename and delete chats.
• Users can export chats using the available mobile export workflow.
• Users can clear all chat history through the supported history-management controls.
• Deleting a conversation does not retrain or modify the underlying base model.

Mobile Think Mode

• Think mode uses a compatible local reasoning workflow for requests that need more analysis.
• Reasoning can take longer than normal chat.
• Reasoning can use more battery and processor time.
• Select a reasoning-oriented model when you need stronger reasoning and the device has enough resources.
• Use smaller reasoning models on memory-constrained devices.
• AI reasoning can still be wrong, incomplete, or misleading.
• Verify high-stakes conclusions independently.

Mobile Search and Research

• Search retrieves current public web information and therefore requires internet access.
• Research performs broader retrieval when supported and also requires internet access.
• Local model inference can still be used to interpret retrieved evidence.
• Web content can contain inaccurate information, malicious instructions, prompt injection, tracking, or unsafe links.
• Treat retrieved content as external evidence rather than trusted application commands.
• Review important sources yourself when accuracy matters.
• Search and Research do not make the entire application cloud-dependent because normal local chat can continue without them.

OpenMindAI Lens

• OpenMindAI Lens provides supported mobile vision workflows.
• Install the OpenMindAI Lens model and its required multimodal projector before using local vision capabilities.
• Use the camera or photo-selection workflow to provide an image.
• The application processes supported image context through the compatible local multimodal model.
• Vision output can contain mistakes in object recognition, text extraction, counting, spatial interpretation, or visual reasoning.
• Do not use OpenMindAI Lens as a guaranteed biometric identity system, medical imaging diagnosis system, legal evidence processor, or safety-critical vision controller.
• Review extracted text and important visual claims manually.

OpenMindAI Hear

• OpenMindAI Hear provides local voice dictation through the supported Whisper transcription workflow.
• Microphone permission is required before the application can capture voice input.
• Audio transcription can be inaccurate when speech is quiet, noisy, heavily accented, interrupted, or contains specialized terminology.
• Review important dictated text before sending or saving it.
• Do not record other people without the consent or legal basis required in your jurisdiction.
• Local voice processing does not mean the operating system or other installed software has no access to device audio according to its own permissions.

OpenMindAI Speak

• OpenMindAI Speak uses device text-to-speech capabilities for supported read-aloud workflows.
• Available voices depend on the operating system and installed speech engines.
• Text-to-speech output can pronounce names, code, formulas, abbreviations, or specialized terms incorrectly.
• Adjust the device language and voice configuration when pronunciation is consistently incorrect.
• Users can stop read-aloud playback through the available application controls.

OpenMindAI Canvas

• OpenMindAI Canvas provides on-device SVG image synthesis using the selected installed OpenMindAI model.
• Canvas uses local vector synthesis rather than silently calling a paid cloud image-generation service.
• Generated SVG content passes through application safety validation before preview when supported.
• Users can preview generated vector artwork.
• Users can save generated Canvas output.
• Users can share generated output through the operating-system share workflow.
• Local vector synthesis is different from heavy diffusion-based image generation.
• A future optional diffusion package can require substantially more storage, memory, battery, and processing power.
• Review generated graphics for visual errors, unsafe embedded content, copyright concerns, and unwanted text before distribution.

Mobile File Attachments

• OpenMindAI Mobile supports attachments for PDF, DOCX, text, Markdown, source code, JSON, YAML, CSV, and other supported text-oriented formats.
• Files are selected through operating-system picker workflows rather than broad unrestricted storage access.
• OpenMindAI stores durable app-private copies of chat attachments so old conversations do not depend on temporary picker paths.
• Storage cleanup can remove orphan attachments that are no longer referenced.
• Large files may exceed available model context or device memory.
• Very large documents should be summarized or processed in sections.
• Generated interpretations and extracted text should be reviewed for accuracy.
• Do not attach confidential files unless you understand the selected feature, storage behavior, and device security.

Android Permissions

• INTERNET permission supports model downloads, Search, Research, updates, Firebase initialization, and other network-dependent functions.
• CAMERA permission supports OpenMindAI Lens camera input and related image workflows.
• RECORD_AUDIO permission supports OpenMindAI Hear voice dictation and other user-initiated audio capture.
• POST_NOTIFICATIONS permission supports completion notifications and other application notifications on Android versions that require explicit notification permission.
• OpenMindAI deliberately avoids broad MANAGE_EXTERNAL_STORAGE access for normal file workflows.
• Files are selected using platform pickers and durable copies are stored inside the application sandbox.
• Users can deny optional camera, microphone, or notification permissions and continue using unrelated features.
• Permissions can be changed later from Android application settings.

iOS Permissions

• Camera permission is used for supported image capture and OpenMindAI Lens workflows.
• Microphone permission is used for OpenMindAI Hear voice input and supported audio capture.
• Photo Library permission is used when the user selects or saves media through supported iOS workflows.
• Notification permission is requested through the application capability flow when notification features are enabled.
• Users can review or revoke permissions from iOS Settings.
• Core text chat should not require camera or microphone permission.
• Permission denial disables the related capability rather than granting the application unrestricted fallback access.

Mobile Storage

• Mobile model files are stored in application-private storage.
• Chat history is stored locally in the mobile application database.
• Durable copies of supported attachments are stored within the application sandbox.
• Generated content can be saved or shared through user-selected platform workflows.
• Mobile storage is more limited than desktop storage, so users should remove optional models they no longer need.
• Keep enough free space for model downloads, temporary files, updates, attachments, generated content, and normal operating-system operation.
• Android and iOS can reclaim temporary caches, but application-private model files remain until removed by the user, application cleanup, or uninstall behavior.
• Back up important exported files separately because uninstalling a mobile application can remove application-private data.

Mobile Performance

• Phones have tighter memory, battery, thermal, and sustained-performance limits than desktop computers.
• The lightweight first-run model is selected to reduce initial storage and memory pressure.
• Larger optional models can provide different capabilities but can consume more memory and run more slowly.
• On-device inference can make the phone warm.
• Extended generation can increase battery consumption.
• Mobile operating systems can throttle the processor when the device becomes hot.
• Background applications can reduce available memory.
• The operating system may terminate OpenMindAI if a model requires more memory than the system can provide.
• Close unnecessary background applications when running larger local models.
• Use a smaller model if the app repeatedly restarts, freezes, or exits during model loading.

Mobile Runtime

• OpenMindAI Mobile uses local GGUF inference through the supported llama-compatible mobile runtime.
• The baseline mobile runtime uses supported CPU execution by default.
• GPU-specific Android Vulkan or iOS Metal packaging is an optional optimization rather than a correctness requirement in the baseline mobile design.
• CPU execution helps keep compatibility predictable across a wider range of mobile devices.
• Future acceleration improvements can change performance without changing the local-first data model.
• Runtime initialization failure should be treated separately from model download success because a downloaded file can exist even when the runtime cannot load it.

Mobile Notifications and Haptics

• Optional notifications can inform users when long responses finish while the application is inactive.
• Notification behavior depends on operating-system permission, battery restrictions, and application background state.
• Haptic feedback can be enabled for important mobile controls where supported.
• Users can disable notifications or haptic behavior through application or operating-system settings.
• Disabling notifications does not disable normal local chat.

Themes and Accessibility

• OpenMindAI Mobile supports System, Light, and Dark theme behavior.
• Compact chat spacing can be used where supported.
• Desktop and mobile interfaces should remain usable with common operating-system text and display scaling settings.
• Users who require assistive technology should keep platform accessibility features enabled and report application controls that are not properly exposed.
• High-contrast, keyboard navigation, focus visibility, screen-reader labeling, and touch-target size should be considered during ongoing application development.

Privacy and Local Data

• Core local inference is designed to operate on the user device.
• Local chat history is stored on the device.
• Local model files remain on the device unless the user intentionally moves or shares them.
• OpenMindAI Mobile uses Firebase Analytics for application-level analytics but does not use its Firebase service to transmit prompts, responses, attachments, model files, or normal chat history for AI processing.
• Desktop connected applications can send data to external providers only when users intentionally use those network-dependent integrations.
• Third-party websites, account providers, application stores, and external APIs have their own privacy practices.
• Do not paste passwords, private keys, seed phrases, recovery codes, access tokens, or other high-risk secrets into ordinary chat.
• Use device encryption and a strong operating-system login or screen lock to protect local OpenMindAI data.
• Delete conversations, attachments, models, and generated files when you no longer need them.
• Review the current OpenMindAI privacy information on the official website before using sensitive data.

Security Guidance

• Download OpenMindAI only from official sources.
• Keep the operating system and security software updated.
• Review application permissions and grant only what you need.
• Treat AI-generated commands as untrusted until reviewed.
• Do not execute destructive shell commands simply because a model suggested them.
• Use Git or another version-control system for source projects.
• Maintain backups before allowing an agent to modify important files.
• Use least-privilege accounts for development and automation.
• Do not store secrets in source files or normal chat history.
• Review connected-app authorization scopes before approval.
• Revoke account connections that are no longer needed.
• Treat untrusted documents and websites as possible prompt-injection sources.
• Verify downloaded models and runtimes from trusted sources.
• Report suspected security vulnerabilities through https://openmindai.vercel.app/contact.

Responsible AI Use

• OpenMindAI output can be inaccurate, incomplete, fabricated, outdated, biased, or misleading.
• AI-generated content does not automatically represent the views or endorsement of OpenMindAI.
• Verify important factual claims before relying on them.
• Do not use OpenMindAI as a replacement for qualified medical diagnosis or emergency care.
• Do not rely on OpenMindAI as a substitute for qualified legal advice.
• Do not treat OpenMindAI as personalized professional financial or investment advice.
• Use academic AI assistance according to institution rules on disclosure, citation, authorship, and originality.
• Verify research references, DOIs, quotations, data, equations, and technical claims before publication.
• Review generated code for vulnerabilities, licensing issues, unsafe dependencies, and destructive behavior.
• Use human oversight and independent safeguards before applying AI output to robots, vehicles, autonomous systems, industrial control, security systems, or other safety-critical environments.
• Do not use OpenMindAI for illegal, abusive, unauthorized, or harmful activity.
• Report inappropriate AI-generated content through the in-app mechanism where available or through https://openmindai.vercel.app/contact.

Model Licenses

• OpenMindAI can use third-party open-weight models under their respective licenses.
• OpenMindAI does not claim ownership of third-party model weights.
• Different models can have different redistribution, commercial-use, attribution, acceptable-use, and modification requirements.
• Installing or using a model through OpenMindAI does not remove the model provider's license obligations.
• Users who deploy OpenMindAI commercially should review the license of every model they choose to distribute or use.
• Raw upstream model names can be hidden in normal user-facing screens while license and attribution requirements remain applicable.
• Model availability can change if upstream licensing, hosting, compatibility, or technical requirements change.

Offline Features

• Local text inference can work offline after the required model and runtime are installed.
• Local desktop chat history can work offline.
• Local mobile chat history can work offline.
• Desktop Projects and attached local workspaces can work offline.
• Project Agent file operations can work offline when they do not require external services.
• Installed model and runtime management can work offline for already-present components.
• Local document processing can work offline where the required parsing and model components are present.
• Supported local media workflows can work offline when their required models and runtimes are installed.
• Local diagnostics and maintenance can work offline.
• Local backups can work offline.
• OpenMindAI Hear local transcription can work offline after required components are present.
• OpenMindAI Speak can work according to locally available device speech capabilities.
• OpenMindAI Canvas local SVG synthesis can work offline.

Features That Require Internet

• Initial application downloads require internet unless an official offline installer is already available locally.
• Model downloads require internet unless the model file is transferred from another trusted local source through a supported workflow.
• Runtime downloads require internet when the runtime is not already installed.
• Application update checks require internet.
• Model update checks require internet.
• Web Search requires internet.
• Research retrieval requires internet.
• Google Workspace connections require internet.
• GitHub connections require internet.
• Microsoft 365 connections require internet.
• Slack connections require internet.
• Notion connections require internet.
• Dropbox connections require internet.
• Remote MCP servers require internet when they are not running on the same local system.
• Application-store installation and updates normally require internet.
• Support website and contact-page access require internet.

Troubleshooting Desktop Startup

• If OpenMindAI does not start, restart the computer and try again.
• Confirm that you installed an official build compatible with your operating system.
• Check that the configured OpenMindAI data drive is connected and accessible.
• Check available system-drive and data-drive space.
• Review antivirus or endpoint-protection logs for blocked application files.
• Update graphics drivers when startup fails during hardware or runtime initialization.
• Update required Windows or platform web-rendering components when the interface opens blank.
• Reinstall the official application if installation files are damaged.
• Do not delete user data as the first troubleshooting step.
• Contact support with platform details, hardware information, reproduction steps, and sanitized logs if the problem continues.

Troubleshooting Model Downloads

• Confirm internet connectivity.
• Confirm that the model source is reachable.
• Check available storage before starting a large download.
• Check whether antivirus scanning is delaying the transfer.
• Check whether a firewall, proxy, VPN, DNS filter, or corporate policy is blocking the model source.
• Cancel and restart a permanently stalled download when resume does not recover.
• Remove an incomplete corrupted file before retrying if verification repeatedly fails.
• Use Wi-Fi for large mobile downloads when mobile-data usage is a concern.
• Keep the device powered during multi-gigabyte transfers.
• Do not manually rename partial download files to final model filenames.

Troubleshooting Model Loading

• Confirm that the model is fully downloaded.
• Confirm that verification completed successfully.
• Confirm that the model format is compatible with the installed runtime.
• Confirm that the device has enough free RAM.
• Confirm that the GPU has enough available memory when GPU offloading is enabled.
• Close memory-intensive applications.
• Reduce context size if the runtime fails only with long conversations.
• Try a smaller quantized model.
• Restart the local runtime.
• Restart OpenMindAI.
• Update graphics drivers and the application when hardware acceleration fails.
• Use CPU fallback where available when the GPU backend is incompatible.

Troubleshooting Chat Routing

• If chat reports that a model is missing, open Model Manager and confirm that a compatible model is installed.
• If the selected model exists but cannot answer, verify that the runtime is running and healthy.
• Automatic routing can choose a different installed model when the requested capability requires it.
• Vision tasks require a compatible vision model and any required projector component.
• Reasoning tasks can require a reasoning-capable model.
• Search and Research require both a compatible local model and a working network retrieval path.
• Document tasks can fail when the file format is unsupported, encrypted, corrupted, or too large.
• Restart the conversation when corrupted or oversized context causes repeated failures.
• Report reproducible routing errors with the task mode, selected model, platform, and sanitized logs.

Troubleshooting Mobile

• If the mobile app closes during model loading, use a smaller model and close other memory-intensive applications.
• If the app becomes hot, stop generation and allow the device to cool.
• If camera input fails, check operating-system camera permission.
• If voice input fails, check microphone permission and confirm another application is not using the microphone.
• If notifications do not appear, check notification permission, battery optimization, background restrictions, and focus settings.
• If a file cannot be attached, try selecting it again through the operating-system picker and confirm that the format is supported.
• If the first-run model download fails repeatedly, check Wi-Fi, available storage, and application background restrictions.
• If a model appears downloaded but cannot load, delete and reinstall the model through Model Manager.
• If history appears missing after a storage problem, avoid clearing application data until you determine whether the local database is still present.
• If the issue continues, contact support with device model, operating-system version, reproduction steps, and non-sensitive logs.

Updating OpenMindAI

• Use the supported application updater, official release channel, Microsoft Store, mobile application store, or other approved distribution path.
• Keep security and stability updates reasonably current.
• Application updates should normally preserve local models and user data, but users should back up important data before major changes.
• Model updates can be separate from application updates.
• Do not replace active model files manually while a runtime is using them.
• Review release notes when a major update changes storage, permissions, model requirements, or agent behavior.
• Organizations should test updates in a controlled environment before broad deployment when OpenMindAI is part of a critical workflow.

Microsoft Store Installation

• Open the official OpenMindAI listing in Microsoft Store when the listing is available in your market.
• Verify the product name and publisher information.
• Select Install or Get.
• Allow Microsoft Store to download and install the desktop application.
• Launch OpenMindAI from the Start menu or Store application page.
• Complete OpenMindAI first-run storage, runtime, and local model setup.
• Microsoft Store distribution does not mean Microsoft created OpenMindAI.
• Store packaging and update behavior can differ from direct desktop installers.
• Store availability can vary by region, device, architecture, and certification status.

Mobile Store Installation

• Use the official OpenMindAI listing in the application store for your mobile platform when available.
• Verify the developer or publisher information before installation.
• Review the store privacy information and requested permissions.
• Install the application through the normal store workflow.
• Open OpenMindAI and complete first-run onboarding.
• Download the lightweight first-run model.
• Optional larger local models remain separate from the main application-store package.
• Application-store distribution does not mean the store operator created or endorses every OpenMindAI feature or AI-generated output.

Developer Overview

• OpenMindAI Desktop uses Tauri for the desktop shell and Rust for the native application backend.
• The desktop frontend uses React and TypeScript.
• Vite is used for frontend build tooling.
• SQLite is used for local application data.
• Tokio supports asynchronous backend work.
• Reqwest supports network and download workflows.
• Local model communication uses llama-compatible local inference behavior.
• OpenMindAI Mobile uses Flutter and Dart.
• Mobile local inference uses the supported llama-compatible mobile library for GGUF models.
• Developers should keep desktop and mobile platform identities, permissions, Firebase configuration, and model provisioning logic consistent with their respective repositories.

Desktop Development Requirements

• Install Node.js 24 to match the current desktop continuous-integration environment.
• Install npm.
• Install a current stable Rust toolchain.
• Install Git.
• Install platform-specific Tauri build dependencies.
• On Windows, install the Microsoft C++ and MSVC toolchain required by Tauri and native dependencies.
• On Linux, install the WebKitGTK and AppIndicator development packages expected by Tauri.
• On macOS, install Xcode Command Line Tools and the required native build dependencies.
• Install or prepare any native local-model runtime dependencies required for the feature set you are building.
• Ensure the development machine has enough disk space for source dependencies, Rust build outputs, frontend packages, native runtimes, and test models.

Clone and Run Desktop Source

• Clone the desktop repository with: git clone https://github.com/smshagor-dev/OpenMindAI.git
• Change into the project directory with: cd OpenMindAI
• Install exact Node dependencies with: npm ci
• Start the Tauri development application with: npm run tauri dev
• Use an official supported Rust toolchain and platform build environment.
• Do not commit model files, runtime binaries that are intentionally generated, local databases, caches, secrets, personal workspaces, or machine-specific configuration unless the repository explicitly requires a particular asset.
• Use feature branches for significant changes and run validation before opening a pull request.

Desktop Frontend Validation

• Check synchronized application metadata with: npm run check:version
• Run frontend linting with: npm run lint
• Run the production frontend build with: npm run build
• Resolve TypeScript, lint, bundling, and version-consistency errors before release preparation.
• Do not bypass failing validation merely to produce an installer.

Desktop Rust Validation

• Check Rust formatting with: cargo fmt --manifest-path src-tauri/Cargo.toml -- --check
• Run Clippy across targets and features with: cargo clippy --manifest-path src-tauri/Cargo.toml --all-targets --all-features -- -D warnings
• Run Rust tests with: cargo test --manifest-path src-tauri/Cargo.toml --all-features
• Resolve compiler warnings that are promoted to errors by the release validation path.
• Test filesystem, runtime, model, database, updater, connected-app, and agent changes at the backend boundary where practical.

Desktop Production Build

• Build the frontend with: npm run build
• Build the desktop application with: npm run tauri -- build
• Release workflows can build platform-specific installer bundles.
• Windows release validation can exercise an NSIS installer path.
• Production release signing and trust configuration must be managed through secure release workflows rather than committed secrets.
• Verify the final installer on a clean or representative machine.
• Test first-run storage selection.
• Test model and runtime provisioning.
• Test normal local chat.
• Test uninstall behavior.
• Test update metadata and update behavior when the release includes updater changes.

Mobile Development Requirements

• Use Flutter 3.44 or newer for the current mobile dependency baseline.
• Use Dart 3.12 or newer for the current mobile dependency baseline.
• Install the Android SDK and required Android build tools for Android development.
• Use Java 17 where required by the current Android configuration.
• Install Xcode and iOS tooling on macOS for iOS builds.
• Keep the committed Android and iOS native hosts intact unless you intentionally regenerate them.
• Keep the configured mobile application identity consistent with the current project.
• Preserve the committed Firebase configuration when regenerating native platform files.
• Use the repository preparation tool before builds to validate platform identity and configuration.

Clone and Prepare Mobile Source

• Clone the mobile repository from the authorized OpenMindAI mobile source.
• Change into the mobile project directory that contains the Flutter application.
• Install Flutter dependencies with: flutter pub get
• Validate and prepare native platform configuration with: dart run tool/prepare_platforms.dart
• Format mobile Dart source with: dart format lib test tool
• Run static analysis with: flutter analyze
• Run mobile tests with: flutter test
• Build a debug Android APK with: flutter build apk --debug
• Do not regenerate native Android or iOS hosts casually because doing so can overwrite required identity, Firebase, permission, or build configuration.
• After deliberate regeneration, restore required configuration and run the platform-preparation tool before building.

Android Release Build

• Configure Android signing securely before producing a release build.
• Do not commit private signing keys or passwords to the repository.
• Build a normal release APK with: flutter build apk --release
• For smaller architecture-specific APK artifacts, build split APKs with: flutter build apk --release --split-per-abi
• Use Android App Bundle packaging when required by the target application store and project release process.
• Test installation on representative physical devices.
• Test onboarding and first-run model download.
• Test camera, microphone, notifications, file pickers, local inference, model deletion, and storage cleanup.
• Verify that the final package uses the expected application identity and Firebase configuration.
• Review store permission declarations before publication.

iOS Development and Build

• iOS development requires macOS and Xcode.
• Prepare Flutter dependencies and platform configuration before building.
• Build a simulator debug target with: flutter build ios --simulator --debug
• Configure the Apple development team, signing, entitlements, bundle identity, and distribution settings through the approved iOS release process.
• Verify camera, microphone, photo-library, and notification usage descriptions before submission.
• Test local model provisioning on representative supported devices.
• Test memory pressure with larger optional models.
• Test background behavior and interruption recovery.
• Review App Store privacy disclosures and application metadata before submission.

Firebase Mobile Configuration

• OpenMindAI Mobile initializes Firebase Core and Analytics for Android and iOS.
• Firebase initialization is not a correctness dependency for local AI startup.
• A Firebase connectivity or initialization failure should not prevent supported offline local inference from opening.
• Android Firebase configuration is maintained in the native Android application configuration file.
• iOS Firebase configuration is maintained in the native iOS application configuration file.
• Generated Flutter Firebase options are maintained in the mobile source.
• The platform preparation tool verifies that Android and iOS identities match the expected Firebase application configuration.
• Do not publish a build that accidentally points to the wrong Firebase project.
• Do not use Firebase Analytics events to include prompt text, model responses, private attachments, chat history, private file contents, tokens, passwords, or other sensitive user content.

Continuous Integration and Release Quality

• OpenMindAI Desktop uses GitHub Actions for continuous integration and release-readiness checks.
• Release validation includes frontend checks, Rust checks, installer build checks, security checks, and consistency validation.
• Security workflows can include dependency auditing and static analysis.
• Release artifacts should be produced only after required validation passes.
• Mobile builds are intentionally prepared locally in the current mobile repository rather than depending on a dedicated GitHub Actions APK workflow.
• Local mobile release preparation should still run formatting, analysis, tests, platform validation, and representative device testing.
• Never treat a successful build alone as proof that model routing, local inference, permissions, updater behavior, or store compliance is correct.

Testing Before Release

• Test fresh installation.
• Test application upgrade from a previous supported installation.
• Test uninstall behavior.
• Test first-run onboarding.
• Test storage selection.
• Test model download progress.
• Test download cancellation.
• Test interrupted download recovery.
• Test model verification.
• Test model activation.
• Test automatic routing.
• Test normal chat.
• Test reasoning.
• Test Stop and Regenerate.
• Test history creation, search, rename, delete, export, and cleanup where available.
• Test offline startup after local setup.
• Test network-dependent Search and Research separately.
• Test attachments.
• Test document generation.
• Test image or vision workflows.
• Test microphone and camera permissions on mobile.
• Test notification behavior.
• Test low-storage behavior.
• Test low-memory behavior.
• Test external desktop storage disconnection and reconnection.
• Test project file operations and terminal permission boundaries on desktop.
• Test connected-app permission and failure behavior.
• Test that sensitive tokens do not appear in normal chat logs.
• Test application-store metadata and privacy declarations before submission.

Performance Recommendations

• Use SSD storage for desktop model files when possible.
• Keep enough free RAM for the selected model and operating system.
• Use a smaller model when memory pressure causes instability.
• Keep context lengths appropriate for the task.
• Close unnecessary heavy applications during large local inference workloads.
• Keep graphics drivers current on desktop systems.
• Use supported hardware acceleration when it is stable for the device.
• Use CPU fallback when GPU acceleration is unavailable or unreliable.
• Keep laptops connected to power for sustained heavy inference when practical.
• Allow mobile devices to cool when thermal throttling reduces performance.
• Use Wi-Fi for multi-gigabyte model downloads.
• Remove unused mobile models to keep enough free storage for updates and temporary files.

Data Management Recommendations

• Keep important project source in version control.
• Keep important generated documents in a backed-up user folder.
• Back up local OpenMindAI conversation history if it contains irreplaceable work.
• Do not rely on a single device as the only copy of critical artifacts.
• Delete stale models that can be downloaded again when storage is limited.
• Review local logs before sharing them with support.
• Remove private file paths, tokens, identifiers, and confidential text from diagnostic material whenever possible.
• Use encrypted storage for sensitive local AI work.
• Use operating-system account separation when multiple people share one computer.
• On mobile, use a secure screen lock and device encryption.

Common Questions About Offline Use

• OpenMindAI can run local AI without internet after the required model and runtime are installed.
• The initial application and model downloads still require a source unless they are already available through a trusted offline package.
• Web Search cannot provide live results without internet.
• Research cannot retrieve current public evidence without internet.
• Connected cloud applications cannot synchronize without internet.
• Local conversation history remains available without internet.
• Local desktop Projects remain available without internet.
• Local mobile document and supported voice workflows remain available when all required components are installed.
• Going offline does not automatically increase model accuracy or security; it mainly changes where inference and data processing occur.

Common Questions About Model Size

• Model size is determined by model architecture, parameter count, precision, quantization, and included assets.
• Quantized models reduce storage and memory requirements.
• A smaller model is usually easier to run on limited hardware.
• A larger model does not guarantee a better answer for every task.
• Vision models can require additional projector or encoder files.
• Image-generation models can be substantially larger than text models.
• Mobile users should consider both storage size and runtime memory requirements before installing large models.
• Desktop users with external SSD storage can maintain a larger catalog, but RAM and VRAM still limit what can run at one time.

Common Questions About Privacy

• Local inference can keep prompt processing on the device.
• Local processing does not automatically protect content from someone who can access the unlocked device.
• Connected services can transmit data to external providers when the user intentionally uses those services.
• Web Search transmits network requests needed to retrieve public information.
• Application-store providers can collect store-level installation or diagnostic information under their own policies.
• Mobile Firebase Analytics is for application-level analytics and is not intended as the path for transmitting AI prompt or response content.
• Users should review current privacy documentation and enabled integrations before processing sensitive information.

Common Questions About AI Accuracy

• OpenMindAI cannot guarantee factual accuracy.
• Models can hallucinate references, commands, APIs, equations, citations, filenames, package names, and configuration settings.
• Models can misunderstand incomplete or ambiguous prompts.
• Models can generate unsafe code.
• Models can produce biased or inappropriate output.
• Retrieved web sources can also be inaccurate.
• Use reliable independent sources for important claims.
• Use automated tests and human review for generated code.
• Use qualified professional review for high-stakes medical, legal, financial, engineering, or safety decisions.

Support Request Checklist

• Describe what you were trying to do.
• Describe what happened instead.
• List clear steps that reproduce the issue.
• Provide the operating system.
• Provide the device or computer hardware details relevant to the problem.
• Provide the OpenMindAI platform, such as Desktop, Android, or iOS.
• Provide the selected OpenMindAI model name when the issue involves inference.
• State whether the feature was local or network-dependent.
• Include a screenshot when it helps and does not expose private information.
• Include sanitized logs when necessary.
• Do not include passwords.
• Do not include private keys.
• Do not include seed phrases.
• Do not include authentication tokens.
• Do not include unnecessary personal or confidential documents.
• Submit support requests through https://openmindai.vercel.app/contact.

Security Vulnerability Reporting

• Report suspected OpenMindAI security vulnerabilities responsibly.
• Do not exploit a vulnerability against other users, systems, accounts, or data.
• Provide technical reproduction information that helps the issue be investigated.
• Remove unrelated user data or secrets from the report.
• Allow a reasonable opportunity for investigation and remediation before public disclosure when responsible disclosure is appropriate.
• Use https://openmindai.vercel.app/contact for the current public contact path.

Documentation Scope and Updates

• This documentation describes the intended OpenMindAI Desktop and Mobile product behavior based on the current project architecture and supported workflows.
• Specific features can change as models, runtimes, operating systems, application stores, third-party providers, and security requirements evolve.
• Model availability and approximate download size can change.
• Application-store availability can change by market.
• Connected-app capabilities can change when providers modify their APIs or permissions.
• Users should check the official website and application release information for current availability.
• Website: https://openmindai.vercel.app/
• Contact: https://openmindai.vercel.app/contact