What happened after I connected Gmail, GitHub, and Notion to OpenHuman?

After installing OpenHuman, I deliberately did not flip on all 118 integrations. The GitBook docs list Gmail, Notion, GitHub, Google Calendar, Slack… For a solo dev or small team, most daily context actually lives in three places: mail for commitments, Notion for specs, GitHub for delivery. I wired up only those three and watched what happened on disk over 72 hours.

Spoiler: OpenHuman is not “three tabs in one chat window.” Once OAuth completes, your Memory Tree starts growing on disk—by default roughly every 20 minutes, auto-fetch (official docs) pulls new mail, page edits, and repo activity, compresses them to Markdown, and writes SQLite plus an Obsidian-style local vault. Chat quality changes are delayed and cumulative: mostly invisible for the first few hours, noticeably better on day two for cross-app questions, and by day three you feel disk and noise as real costs.

1. Why Gmail, GitHub, and Notion first

Together they cover about 80% of context I’d want an assistant to cite:

• Gmail — scope changes, verbal deadlines, contract attachments—often never copied into Notion.
• Notion — PRDs, API contracts, meeting notes—structured, but disconnected from the repo timeline and mail threads.
• GitHub — who merged what, CI status, issue promises—the ground truth of delivery, in a different UI from sales mail.

ChatGPT or Copilot can swallow one paste at a time, but won’t keep three moving sources aligned. OpenHuman’s bet is piping all three into one local memory store. Repo: tinyhumansai/openhuman. If you’re already thinking always-on hosting, see the companion piece Run OpenHuman on a cloud Mac.

2. Day zero: OAuth and the first fetch

All three use browser OAuth—far less painful than rolling your own API keys. Order I recommend:

1. Gmail first — keep scope tight; skip “sync entire mailbox history.” Last 30 days or an Important label is enough, or the first index run drags forever.
2. Notion second — grant only databases and pages you actively maintain; skip marketing archives.
3. GitHub last — authorize per org/repo; leave hobby repos disconnected.

After the final “Allow,” the UI won’t feel genius yet. A full pull runs in the background: Gmail threads become summary chunks, Notion pages become Markdown nodes, GitHub commits/PRs/issues land under per-repo folders. CPU and disk I/O spike—Activity Monitor shows OpenHuman reading and writing steadily.

When round one finishes, open Memory Tree (or the Obsidian-style wiki folder). Top level looks roughly like:

memory/
├── gmail/
│   ├── threads/          # per-thread mail summaries
│   └── contacts/         # sender ↔ project hints (if enabled)
├── notion/
│   ├── pages/            # page Markdown mirrors
│   └── databases/        # database row snapshots
└── github/
    ├── repos/
    ├── commits/
    ├── pull-requests/
    └── issues/

Ask “summarize my last week” immediately and answers stay vague—the model hasn’t linked sources yet, only ingested separate piles of text. Normal; don’t bail yet.

3. What each source looks like once indexed

HTML mail, Notion blocks, and GitHub JSON all get flattened to Markdown before storage—that’s what makes the tree diffable and searchable. Open any .md in Finder: you see rawer excerpts than the chat UI, which helps separate “bad fetch” from “bad reasoning.”

4. From day two: cross-app questions start working

After roughly 4–6 auto-fetch cycles (overnight in practice), I asked things that used to require copy-paste across three apps. These actually improved (client names anonymized):

• “Client A moved launch from 6/15 to 6/22 in mail—do the Notion PRD and GitHub milestone match?” — the twin cited thread dates, page revision, and milestone titles and returned a mismatch list.
• “Which PRs did I merge in repo X this week, and do they match scope promised in mail?” — works when mail mentions the repo or PR number.
• “Meeting notes say add a rate limit—did that land in code?” — strong hit rate when Notion notes and PR descriptions align.

Common thread: answers are alignment and drift detection, not “write the code” or “send the mail.” At this stage OpenHuman feels like an intern who read three inboxes—not an autonomous agent. Expecting it to edit Notion or open PRs is OpenClaw territory; memory vs execution are different layers.

5. Three surprises I didn’t budget for

5.1 Disk grows faster than chat quality

After 48 hours on three connectors, my vault went from under 200MB to about 1.2GB (personal load; full multi-year Gmail would be far worse). Monorepo commit history and large Notion databases dominated. From day one:

• du -sh …/memory daily for a baseline;
• revoke stale Notion workspaces;
• GitHub: active repos only, disconnect archived ones.

5.2 Noise poisons “what did I do last week?”

GitHub mails in Gmail, blank Notion templates, dependabot commits—all index. Weekly summaries may count bots. Mitigations: Gmail label filters; ignore archived repos at org level; constrain prompts (“only commits with feat: or client name X”).

5.3 Lid closed = memory gap

On a MacBook, I closed the lid for a two-hour meeting—auto-fetch logs showed a hole; “did the client reply last night?” was wrong Thursday morning. Not a bug: sleep pauses scheduled fetch. If these three sources are core, use clamshell power + never sleep, or move the twin to an always-on host (below).

6. After a week: how my habits shifted

Seven stable days turned occasional chats into three rituals:

1. Five-minute morning — “client mail + blocking PRs + Notion urgent items in 24h” instead of app-hopping.
2. Before replying — “draft scope-confirmation mail from thread X and the Notion API page” — I still hit Send myself, but drafts are usable.
3. Friday — “inconsistencies across the three sources for project Y” — faster than a spreadsheet, with spot-checks on cited .md files.

I skipped Calendar and Slack for now—not because they’re useless, but to prove the triangle is worth the upkeep. If you live in meetings, Calendar as a fourth connector often beats Slack (threads are noisier than mail).

7. If you’re about to connect: four practical rules

1. Stage connectors — one new source per 24h; watch disk and CPU.
2. Treat Memory Tree as source of truth — when the model errs, open the .md first.
3. Model routing is separate — local vault doesn’t mean local inference; corporate mail under DLP shouldn’t land on a personal twin.
4. Back up SQLite + Markdown — this machine holds a professional clone of you; encrypted backups or rsync, not public cloud sync folders.

du -sh ~/Library/Application\ Support/OpenHuman/memory 2>/dev/null \
     || du -sh ~/Documents/OpenHuman/memory 2>/dev/null
find . -name "*.md" -mtime -1 | wc -l

8. FAQ

Q1: Are three connectors enough?
For many knowledge workers, yes—to validate value. Tune noise and disk before adding ten more sources or search gets sluggish.

Q2: Doesn’t Gmail Gemini / Notion AI cover this?
Those are single-app assistants. OpenHuman’s angle is cross-source persistent index on your machine.

Q3: Private GitHub repos?
OAuth tokens stay local; risk is full-vault backup leakage. FileVault, separate user, no dumping the vault into Dropbox.

Q4: Is 72 hours enough to decide?
Usually. If cross-app answers still hallucinate and you won’t curate the tree, stay with status quo; if morning ritual already saves time, consider always-on hosting.

Q5: Must I use a cloud Mac?
No—but if lid-close gaps bit you twice, see the next section.