OpenHuman 20-Minute Sync Integrations: How to Configure Auto-Fetch Intervals

OpenHuman's auto-fetch scheduler synchronizes all native provider integrations every 20 minutes, with per-connection toggles available in Settings → Integrations to enable or disable automatic syncing.

The tinyhumansai/openhuman repository maintains a continuous 20-minute sync cycle that automatically pulls fresh data from connected services into your Memory Tree. This fixed-interval auto-fetch system applies universally to all integrations shipping a native Rust provider, ensuring your knowledge base stays current without manual intervention.

Which Integrations Support 20-Minute Sync

All integrations that ship a native provider—a Rust module that knows how to ingest the service—participate in the 20-minute auto-fetch schedule. According to the integrations catalog in gitbooks/features/integrations/README.md, the following categories and services are supported:

Email, Calendar, and Productivity

• Email & Calendar: Gmail, Outlook, Google Calendar, Apple Calendar
• Productivity Tools: Notion, Todoist, Asana, ClickUp

Development and Communication Platforms

• Code & Dev: GitHub, GitLab, Bitbucket
• Communication: Slack, Discord, Microsoft Teams, Telegram, WhatsApp, Signal, Matrix

Storage, Finance, and Project Tracking

• File & Drive: Google Drive, Dropbox, OneDrive
• Payments & Finance: Stripe, PayPal
• Issue & Project Tracking: Linear, Jira, Trello, ClickUp

The actual provider implementations reside in src/openhuman/memory_sync/composio/providers/**/*.rs, where each Rust module handles the ingestion logic for its respective service. Registration of these adapters and their auto-fetch capabilities is managed in src/openhuman/integrations/mod.rs.

How to Configure Auto-Fetch Intervals

The 20-minute interval is fixed and cannot be customized per-integration. However, you control whether individual connections participate in this schedule.

Enabling Auto-Fetch via the UI

To activate the 20-minute sync for a specific connection:

1. Navigate to Settings → Integrations
2. Select your desired service and click Connect to complete the OAuth flow
3. Once connected, toggle the "Auto-fetch" switch to ON

This adds the connection to the scheduler's loop defined in src/openhuman/scheduler/mod.rs. To pause syncing, return to the same Settings screen and disable the toggle.

Programmatic Control with JSON-RPC

For advanced automation, the core exposes the integration.toggle_auto_fetch method. This JSON-RPC endpoint accepts a connection ID and boolean flag:

{
  "jsonrpc": "2.0",
  "method": "integration.toggle_auto_fetch",
  "params": {
    "connection_id": "gmail-12345",
    "enabled": true
  },
  "id": 1
}

Set "enabled": false to remove the connection from the 20-minute rotation without deleting the integration.

Verifying Scheduler Status

Confirm the scheduler is actively processing the 20-minute tick by querying the health endpoint:

curl http://127.0.0.1:8000/health | jq .scheduler

The response includes a next_tick timestamp indicating the next 20-minute interval and a list of connections queued for auto-fetch.

Technical Implementation Details

The auto-fetch mechanism is documented in gitbooks/features/obsidian-wiki/auto-fetch.md, which describes how the scheduler triggers a tick every twenty minutes and walks all active connections. The scheduler core in src/openhuman/scheduler/mod.rs maintains this cadence, while individual provider implementations in src/openhuman/memory_sync/composio/providers/**/*.rs execute the actual data ingestion into the Memory Tree.

Summary

• All native providers participate in OpenHuman's fixed 20-minute sync cycle, including Gmail, Slack, GitHub, Notion, and Google Drive
• The auto-fetch interval is hardcoded at 20 minutes and cannot be adjusted per-integration
• Enable or disable syncing per connection via the Settings → Integrations UI toggle or the integration.toggle_auto_fetch JSON-RPC method
• Monitor scheduler health using the /health endpoint to verify the next 20-minute tick is scheduled

Frequently Asked Questions

Can I change the 20-minute auto-fetch interval?

No. The 20-minute interval is fixed in the scheduler core at src/openhuman/scheduler/mod.rs and applies universally to all native provider integrations. You cannot configure custom intervals for individual connections.

How do I know if an integration supports automatic syncing?

Check the integrations catalog at gitbooks/features/integrations/README.md. Any service listed there with a native Rust provider in src/openhuman/memory_sync/composio/providers/ supports the 20-minute auto-fetch. Third-party integrations without native providers do not participate in the automatic schedule.

What happens when I disable auto-fetch for a connection?

Disabling auto-fetch removes the connection from the scheduler's 20-minute loop immediately. The connection remains authenticated and available for manual syncs, but the system will no longer automatically pull fresh data every twenty minutes until you re-enable the toggle.

How can I verify the scheduler is running correctly?

Query the health endpoint at http://127.0.0.1:8000/health and inspect the scheduler object in the JSON response. A healthy system returns a next_tick timestamp exactly 20 minutes from the last execution and lists all connections currently enrolled in auto-fetch.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}