diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index c6810637a..4bb10c50a 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -3,6 +3,9 @@ name: Build on: pull_request: branches: ['*'] + paths: + - 'src/**' + - 'src-tauri/**' permissions: contents: read diff --git a/.github/workflows/package-and-publish.yml b/.github/workflows/package-and-publish.yml index dffeab0a0..92e2a7601 100644 --- a/.github/workflows/package-and-publish.yml +++ b/.github/workflows/package-and-publish.yml @@ -14,7 +14,7 @@ on: # branches: # - main workflow_run: - workflows: ['Version Bump'] + workflows: ["Version Bump"] types: - completed branches: @@ -171,15 +171,15 @@ jobs: fail-fast: false matrix: settings: - - platform: 'macos-latest' - args: '--target aarch64-apple-darwin' - target: 'aarch64-apple-darwin' - - platform: 'macos-latest' - args: '--target x86_64-apple-darwin' - target: 'x86_64-apple-darwin' - - platform: 'ubuntu-22.04' - args: '' - target: '' + - platform: "macos-latest" + args: "--target aarch64-apple-darwin" + target: "aarch64-apple-darwin" + - platform: "macos-latest" + args: "--target x86_64-apple-darwin" + target: "x86_64-apple-darwin" + - platform: "ubuntu-22.04" + args: "" + target: "" runs-on: ${{ matrix.settings.platform }} steps: - name: Checkout @@ -200,7 +200,7 @@ jobs: uses: actions/setup-node@v4 with: node-version: 24.x - cache: 'yarn' + cache: "yarn" - name: Install Rust stable uses: dtolnay/rust-toolchain@stable @@ -323,7 +323,7 @@ jobs: # macOS 10.15+ required for std::filesystem used by llama.cpp MACOSX_DEPLOYMENT_TARGET: ${{ matrix.settings.platform == 'macos-latest' && '10.15' || '' }} with: - args: '-c ${{ steps.config-overrides.outputs.json }} ${{ matrix.settings.args }}' + args: "-c ${{ steps.config-overrides.outputs.json }} ${{ matrix.settings.args }}" includeDebug: ${{ needs.get-version.outputs.should-publish == '' && inputs.forceRelease != 'true' }} includeRelease: ${{ needs.get-version.outputs.should-publish != '' || inputs.forceRelease == 'true' }} # TDLib dylibs are now bundled natively via build.rs + tauri.conf.json macOS.frameworks diff --git a/gitbooks/README.md b/gitbooks/README.md index 5d9312724..dc8478ecb 100644 --- a/gitbooks/README.md +++ b/gitbooks/README.md @@ -3,10 +3,10 @@ description: >- OpenHuman is a personal AI assistant that runs natively across desktop, mobile, and web that connects your communication platforms, tools, and workflows into a single intelligence layer you control. -icon: hand-wave +icon: diamond --- -# Welcome +# Welcome to OpenHuman OpenHuman is the first open-source AI agent with Big Data capabilities and a personalized subconscious mind. Built on the OpenClaw architecture and licensed under GNU GPL3, OpenHuman is designed to close the gap between what AI models can do and what they actually know about you. @@ -38,6 +38,8 @@ It **thinks proactively** through its subconscious system, making connections an It **preserves privacy** by design. Raw data stays on your device. Encryption keys never leave the device. Only compressed metadata and summaries are processed server-side. + + ## Who it's for OpenHuman is built for people and teams who operate across many conversations and tools, and feel the cost of it. diff --git a/gitbooks/SUMMARY.md b/gitbooks/SUMMARY.md index 23afad90e..8f285e84e 100644 --- a/gitbooks/SUMMARY.md +++ b/gitbooks/SUMMARY.md @@ -2,20 +2,33 @@ ## Overview -* [Welcome](README.md) +* [Welcome to OpenHuman](README.md) +* [How It Works](overview/how-it-works.md) * [Getting Started](overview/getting-started.md) -* [How Does It Work?](overview/how-it-works.md) + +## Technology + +* [Neocortex](technology/neocortex.md) +* [The Subconscious](technology/the-subconscious.md) * [Architecture](technology/architecture.md) -* [Platform & Availability](overview/platform.md) -## Features +## Product -* [Neocortex Memory](features/neocortex.md) -* [Subconscious Loop](features/the-subconscious.md) +* [Platform & Availability](product/platform.md) * [Skills & Integrations](product/skills-and-integrations.md) * [Teams & Organizations](product/teams.md) +* [Privacy & Security](product/privacy-and-security.md) * [Pricing](product/pricing.md) +## Use Cases + +* [Overview](use-cases/overview.md) + ## Resources * [FAQ & Troubleshooting](resources/faq.md) + +## Legal + +* [Terms & Conditions](legal/terms-of-use.md) +* [Privacy Policy](legal/privacy-policy.md) diff --git a/gitbooks/overview/getting-started.md b/gitbooks/overview/getting-started.md index 3ffa98144..c8249b863 100644 --- a/gitbooks/overview/getting-started.md +++ b/gitbooks/overview/getting-started.md @@ -1,5 +1,5 @@ --- -icon: baby-carriage +icon: play --- # Getting Started diff --git a/gitbooks/product/platform.md b/gitbooks/product/platform.md new file mode 100644 index 000000000..5ac02ffc2 --- /dev/null +++ b/gitbooks/product/platform.md @@ -0,0 +1,68 @@ +--- +icon: layer-plus +--- + +# Platform & Availability + +OpenHuman is a native application that runs on six platforms from a single codebase. It is not a web-only tool, browser extension, or Electron wrapper. It is built for performance, security, and a small footprint on every device you use. + +*** + +## Six Platforms, One Experience + +OpenHuman compiles to native binaries for each supported platform: + +| Platform | Architectures | Distribution | +| ----------- | -------------------- | -------------- | +| **macOS** | Intel, Apple Silicon | .dmg installer | +| **Windows** | x64, ARM64 | .msi installer | +| **Linux** | x64, ARM64 | AppImage, .deb | +| **Android** | ARM | .apk package | +| **iOS** | ARM64 | App Store | +| **Web** | Any browser | Direct access | + +Your account, connected sources, preferences, and settings sync across all platforms. You can start a request on your desktop and review the output on your phone. + +*** + +## Why Native Matters + +OpenHuman is built as a native application rather than a web wrapper for three reasons. + +**Small footprint.** The app is lightweight. A fraction of the size of typical communication tools. It starts in under a second and uses minimal memory, so it stays out of the way when running alongside other demanding applications. + +**Fast startup.** There is no browser engine to initialize. The app launches quickly and is ready to accept requests immediately. + +**OS-level security.** On desktop platforms, OpenHuman stores credentials in your operating system's secure keychain (macOS Keychain, Windows Credential Manager, Linux Secret Service). Sensitive data never sits in browser storage or plain text files. + +*** + +## Architecture at a Glance + +OpenHuman operates across three layers: + +**Application layer.** The native app on your device handles the interface, user input, local state, credential management, and skill execution. This layer is responsible for everything you see and interact with. + +**Intelligence layer.** OpenHuman's analysis, coordination, and intelligence systems run as a secure backend service. When a request requires deeper language processing, it is handled here. This layer is operated and maintained by OpenHuman. + +**External services.** Connected tools and platforms:Telegram, Notion, Google Sheets, and others are accessed only when you explicitly request it. OpenHuman acts as a bridge between your sources and the intelligence layer, not as a replacement for any of them. + +{% hint style="info" %} +The intelligence layer is not part of the client application. It performs analysis, coordination, and trust scoring separately from the frontend. +{% endhint %} + +*** + +## Real-Time Communication + +OpenHuman maintains a persistent connection between the application and the intelligence layer. This means responses arrive in real time as they are generated. You see outputs streaming, not loading. + +The connection is designed for resilience. If the network drops, OpenHuman reconnects automatically with progressive backoff. There is no manual reconnection process. + +*** + +## Offline Behavior + +OpenHuman's local state persists on your device. Your preferences, settings, and connected source configurations remain available even when you are offline. + +Full analysis and intelligence features require a network connection, since they depend on the intelligence layer. When connectivity is restored, the app resumes normal operation without requiring you to re-authenticate or reconfigure. diff --git a/gitbooks/product/privacy-and-security.md b/gitbooks/product/privacy-and-security.md new file mode 100644 index 000000000..466fded43 --- /dev/null +++ b/gitbooks/product/privacy-and-security.md @@ -0,0 +1,125 @@ +--- +icon: shield +--- + +# Privacy & Security + +OpenHuman operates on a principle of **zero-knowledge intelligence**. The system is architecturally designed so that your raw data never needs to leave your device. Neocortex compresses your data locally into structured metadata and summaries. Only this compressed output is processed server-side. Your AI has months of context about your entire organizational life. Your raw data has never touched our servers. + +*** + +## Privacy by Design + +OpenHuman operates on a principle of **zero retention** for message content. When you make a request, the relevant data is processed to produce an output, and the source content is discarded afterward. + +**No long-term message storage.** OpenHuman does not maintain a persistent archive of your conversations. Context is reconstructed from your connected sources when needed. + +**No training on your data.** Your conversations, analysis results, and personal information are never used to train AI models or improve systems. Your data serves you and only you. + +**OS-level credential storage.** On desktop platforms, OpenHuman uses your operating system's secure keychain to store credentials and sensitive tokens. Credentials are never stored in plain text, browser storage, or application-level databases. + +**On-device where possible.** Interface rendering, input handling, local state management, and credential operations all happen on your device. Only tasks requiring deeper language processing are handled server-side, under the same privacy constraints. + +*** + +## Permissions and Access Control + +OpenHuman operates on an **explicit-access model**. It only accesses data when you issue a request, and only the data needed to fulfill that request. + +### Request-Scoped Access + +Access is determined by your requests, not by background monitoring. If you ask OpenHuman to summarize a specific conversation, only that conversation is processed. If you do not reference a source, it is not accessed. + +OpenHuman does not silently expand its access over time. There is no progressive permission creep. + +### Source-Specific Permissions + +Each connected source has its own permission scope: + +* **Telegram:** Read-only access. OpenHuman can read messages from conversations you reference in a request. It cannot send messages, edit messages, react, join groups, or act on your behalf. +* **Notion:** Write access to specific workspaces or pages you approve. OpenHuman does not read unrelated documents. +* **Google Sheets:** Write access to specific spreadsheets you approve. OpenHuman does not read unrelated sheets. + +Integration permissions are limited to what is needed for the specific action you request. + +### User-Initiated Actions Only + +Every meaningful operation in OpenHuman is user-initiated. Summaries, analysis, trust evaluation, workflow creation, and exports all require a direct request. There is no continuous background processing or monitoring. + +{% hint style="info" %} +OpenHuman is idle unless you ask it to do something. +{% endhint %} + +*** + +## Revoking Access + +You can revoke OpenHuman's access to any connected source at any time. + +* Disconnect a source from your settings +* Remove integration permissions +* Stop using the application entirely + +Once access is revoked, OpenHuman immediately stops processing data from that source. There is no delayed or cached processing after revocation. Previously exported outputs (such as summaries written to Notion or Google Sheets) remain where they were written, but no new processing occurs. + +This makes OpenHuman safe to test, pause, or stop using without residual exposure. + +*** + +## Security + +OpenHuman implements security at every layer of the system. + +**AES-256-GCM encryption.** All sensitive data stored locally is encrypted using AES-256-GCM. Encryption keys are derived from your credentials and stored in your operating system's secure keychain. Keys never leave the device. Even if server-side infrastructure were compromised, your raw data would remain inaccessible because it was never there. + +**Secure credential storage.** On desktop platforms, credentials are stored in the operating system's secure keychain. On web, short-lived tokens and secure session management are used instead. + +**Sandboxed skills.** Each skill runs in its own isolated execution environment with enforced memory and resource limits. Skills cannot access each other's data, the host system's file system, or your credentials. + +**Encrypted transit.** All communication between the application and OpenHuman's servers uses encrypted connections. No data travels in plain text. + +**Short-lived tokens.** Authentication tokens are time-limited and single-use where applicable, reducing the window of exposure if a token is compromised. + +*** + +## How Neocortex enables privacy + +Most AI assistants face a tradeoff: more context means more raw data sent to the cloud. Neocortex eliminates this tradeoff. + +Because Neocortex compresses millions of tokens into structured knowledge graphs on-device, the server only ever receives compressed metadata. The knowledge graph contains entities, relationships, and temporal patterns. It does not contain your actual messages, emails, or documents. + +Compression itself becomes the privacy architecture. The raw data never needs to exist outside your device in the first place. + +
+ +## Trust & Risk Intelligence + +OpenHuman includes an intelligence layer designed to help you reason about credibility, information quality, and potential risks across your connected sources. + +### What It Does + +**Scam and impersonation signals.** OpenHuman can surface behavioral patterns associated with scams, impersonation, or coordinated abuse. These signals are derived from patterns observed across contexts, not from individual message content. + +**Contextual dynamic trust.** Trust is represented through aggregated artifacts, historical accuracy of claims, consistency of contributions, peer interaction patterns rather than static scores or universal ratings. Trust is always contextual: credibility in one domain does not automatically transfer to another. + +**Advisory, not enforcement.** OpenHuman does not ban users, remove messages, block actions, or enforce moderation decisions. Trust and risk outputs are advisory signals that inform your judgment. You decide how to act on them. + +### Scope + +Trust and risk intelligence operates at different levels: + +* **Personal:** Visible only to you. Your own analysis, trust assessments, and risk alerts. +* **Community:** Aggregated patterns within a group or organization, supporting shared coordination and moderation. Never exposes individual message content. +* **Network:** Anonymized patterns across the broader OpenHuman user base, improving early detection of shared risks like recurring scam vectors. + +Information does not move between scopes without abstraction and anonymization. + +*** + +## Shared Environments + +When OpenHuman is used in team or community settings, privacy remains user-centric. + +OpenHuman does not grant administrators the ability to read private messages through another user's account. Each user's permissions apply only to their own connected sources. + +Community-level intelligence is derived from aggregated and anonymized signals, not from direct access to individual message content. Shared insights help teams coordinate effectively without compromising individual privacy.