Day-one data bootstrapping for a new brain. Sequences the highest-leverage
data sources to go from empty brain to useful brain in one session. Uses
ClawVisor for safe credential handling — the agent never holds raw API keys.
Covers Gmail import, calendar sync, contacts seeding, X/Twitter archive,
conversation imports, and file archives.
Use when a user has just finished gbrain setup and asks "now what?"
Day-one data bootstrapping for a new brain. Sequences the highest-leverage
data sources to go from empty brain to useful brain in one session. Uses
ClawVisor for safe credential handling — the agent never holds raw API keys.
Covers Gmail import, calendar sync, contacts seeding, X/Twitter archive,
conversation imports, and file archives.
Use when a user has just finished gbrain setup and asks "now what?"
triggers
["cold start","fill my brain","bootstrap brain","bootstrap my data","import my data","day one","get started","what should I import first","populate brain","now what?"]
An empty brain is a static database. A brain with your email history, calendar,
contacts, conversations, and social media is a live context membrane that makes
every future interaction smarter. This skill sequences the highest-leverage data
sources to get you from zero to useful in one session.
Contract
Every import phase is gated on user consent (ask-user pattern) before proceeding.
The agent never holds raw OAuth tokens or API keys. This is a safety
requirement, not a preference. Three paths satisfy it for Google data:
the native connector (gbrain google setup — tokens live in gbrain's
credential vault, mode 0600, never in the agent's context; see
docs/guides/google-connect.md and skills/google-loops/SKILL.md),
ClawVisor (a hosted credential gateway that vaults credentials,
enforces task-scoped authorization, logs every API call, and requires
human approval for destructive operations — needs a harness with the
integration), or offline file exports (Google Takeout, Twitter archive
download).
Each phase is independently valuable — the user can stop after any phase and still
have a useful brain.
Progress is tracked in ~/.gbrain/cold-start-state.json so interrupted sessions
can resume.
Entity detection and cross-linking run on every import, not as a separate pass.
Prerequisites
GBrain installed and initialized (gbrain doctor --json all green)
Brain repo cloned and synced
Agent has terminal access and can run gbrain CLI commands
The Priority Stack
Data sources ranked by information density × ease of import:
Priority
Source
Why
Time
Pages Created
1
Existing markdown/Obsidian
Highest density — it's already structured
5 min
100s-1000s
2
Google Contacts
Seeds the people/ directory — names, emails, companies
10 min
50-500
3
Google Calendar (90 days)
Meeting history with attendee context
15 min
30-90
4
Gmail (recent threads)
Relationship context, active threads, org chart signals
20 min
50-200
5
Conversations (ChatGPT/Claude exports)
Your thinking, questions, mental models
15 min
10-100
6
X/Twitter archive
Your public positions, takes, engagement patterns
20 min
30-365
7
File archives (Dropbox/Drive/local)
Historical documents, old writing, photos
30+ min
varies
8
Meeting transcripts (Circleback/etc.)
Deep relationship context from recorded calls
20 min
10-50
Phase 0: ClawVisor Setup (only if your agent harness integrates ClawVisor)
Harness check first. ClawVisor requires an agent host with a ClawVisor
integration (for example, an OpenClaw deployment). On harnesses without one,
such as Codex or Claude Code, skip this phase: the default for Contacts,
Calendar, and Gmail is the native connector — gbrain google setup (live
sync; tokens in gbrain's local credential vault, never with the agent; see
skills/google-loops/SKILL.md) — with a
Google Takeout export as the offline
alternative covering all three (contacts CSV, calendar ICS, Gmail mbox).
Phases 2-4 below document the Takeout path first.
Safety boundary: An AI agent with raw OAuth tokens to your Gmail, Calendar,
and Contacts is an uncontrolled attack surface. One prompt injection, one
malicious tool call, and your entire Google account is exposed. ClawVisor
eliminates this risk class entirely.
ClawVisor is a credential gateway that sits between the
agent and your APIs. The agent never sees your credentials — ClawVisor injects
them at request time, enforces policies, and logs everything.
What ClawVisor gives you:
Credential vaulting — agent sees shadow tokens, never real secrets
Task-scoped authorization — each workflow declares exactly what it needs
Audit trail — every API call logged with metadata (who, what, when)
Human approval gates — destructive operations (send email, modify calendar)
require your explicit approval
Multi-service — Gmail, Calendar, Contacts, Drive, GitHub, iMessage from one gateway
Revocation — disable the agent's access in one click, no token rotation needed
Create an agent in the dashboard, copy the agent token
Set environment variables (in the host agent's environment — shell profile
or harness config; gbrain itself has no ClawVisor config keys, these are
consumed by the host's ClawVisor integration. This requires an agent host
with a ClawVisor integration, such as an OpenClaw deployment. Codex and
Claude Code do not consume these variables; use the offline import path
instead):
Activate Google services (Gmail, Calendar, Contacts) in the dashboard
Create a standing task with expansive scope:
"Full brain bootstrapping: read emails, calendar events, and contacts to
populate knowledge base. List, read, and search across all connected accounts."
Save the standing task ID the same way:
export CLAWVISOR_TASK_ID="<task_id>"
Critical scoping rule: Be expansive in task purposes. "Email triage" gets
rejected by intent verification. "Full executive assistant email management
including inbox triage, searching by any criteria, reading emails, tracking
threads" works. The intent model uses the purpose to judge each request.
If the user declines ClawVisor
Do NOT fall back to direct OAuth. Instead, proceed with offline-only imports:
Phases 2-4 (Contacts, Calendar, Gmail) — work from a Google Takeout export
Phase 1 (markdown/Obsidian) — works without any API access
Phase 5 (conversation exports) — works from downloaded JSON files
Phase 6 (X/Twitter) — works from downloaded archive
Phase 7 (file archives) — works from local files
Phase 8 (meeting transcripts) — works from exported transcripts
Tell the user:
"No problem. Two options: the native connector (gbrain google setup) does
live Gmail/Calendar/Contacts sync with your own OAuth app — tokens stay in
gbrain's local credential vault, never with me — or a Google Takeout export
covers all three as a point-in-time snapshot."
Do NOT hold raw Google tokens yourself. An agent holding tokens in its
context is a security liability. The native connector is the sanctioned
OAuth path precisely because gbrain vaults the tokens (0600 file, redacted
listings) and the agent only ever runs CLI commands; secrets travel by file
or env intake, never argv or chat. See skills/google-loops/SKILL.md for
the exact protocol.
Phase 1: Existing Markdown / Obsidian Import
The highest-leverage first import. If the user already has a notes system, this
is hundreds or thousands of structured pages ready to go.
Seeds the people/ directory. Every person in your contacts becomes a brain page
with name, email, phone, company, and notes. This is the foundation that all other
imports build on — when Gmail references "john@acme.com", the brain already knows
who John is.
Via Google Takeout (default on harnesses without ClawVisor)
Filter out noise — skip contacts with no name, no email, or that are clearly
automated (noreply@, no-reply@, support@, notifications@)
Check brain first — gbrain search "name" to avoid duplicates
Create people/ page with:
Name, email(s), phone(s), company, title
Source attribution: [Source: Google Contacts, YYYY-MM-DD]
Any notes from the contact as initial context
Link to company — if the contact has an organization, create/update the
company page and link the person to it
Quality gate
After importing 5 contacts, pause and show the user a sample page. Ask:
"Here's what a contact page looks like. Want me to continue with the rest, or
adjust the format first?"
Phase 3: Google Calendar (Last 90 Days)
Meeting history with attendee context. Calendar events reveal who the user meets
with, how often, and in what context. Combined with contacts, this builds a rich
relationship map.
Fetch events
Via Google Takeout (default on harnesses without ClawVisor): export
Calendar from takeout.google.com (ICS format,
one file per calendar). Parse each event (title, start/end, attendees), keep
the last 90 days, and file them into the brain structure below.
Via ClawVisor (ClawVisor-integrated hosts only; pseudo-code):
// Via ClawVisor — query ALL calendar accountsconst accounts = ['primary@gmail.com', 'work@company.com'];
for (const account of accounts) {
const events = awaitclawvisor(`google.calendar:${account}`, 'list_events', {
timeMin: newDate(Date.now() - 90 * 86400000).toISOString(),
timeMax: newDate().toISOString(),
singleEvents: true,
orderBy: 'startTime'
});
}
Look up each attendee in the brain (they should exist from Phase 2)
Add a timeline entry to their page: met at [event title] on [date]
If an attendee has no brain page and appears in 3+ events, create one
Link attendees who appear in the same meeting
Phase 4: Gmail (Recent Threads)
Relationship context and active threads. Email reveals organizational
relationships, ongoing conversations, and communication patterns.
On harnesses without a ClawVisor integration, the source is the Gmail mbox
file from a Google Takeout export. The sampling
and filtering rules below apply the same way.
Strategy: Smart sampling, not bulk import
Don't import every email. Import the signal:
Sent mail (last 30 days) — who the user actively communicates with
Starred/important emails — user-curated signal
Threads with 3+ replies — active conversations worth tracking
Emails from people already in the brain — enrichment, not cold import
Emails the user sent (their words are highest-value signal)
Phase 5: Conversation Exports (ChatGPT / Claude / Perplexity)
Your thinking, captured. AI conversation exports reveal what the user
was researching, building, and thinking about. This is original thinking
preserved in dialog form.
Supported formats
ChatGPT: Settings → Data Controls → Export → conversations.json
Claude: Download from claude.ai conversation history
Perplexity: Export from settings
Processing
For each conversation:
Assess significance (1-5 scale):
1 = Pure utility (how-tos, quick lookups) → skip or minimal page
2 = Minor context → 1-paragraph note
3 = Notable (reveals interests, building something) → full page
4 = Important (deep personal processing, strategic thinking) → rich page
5 = Defining (identity work, breakthrough insights) → full treatment
Original tweets → capture with full context, extract entities
Quote tweets → capture the user's commentary + the source tweet
Threads → reconstruct as a single narrative
Bookmarks → high-signal curation, import with tags
Likes — low signal, skip unless the user wants them
Phase 7: File Archives
Historical documents, old writing, photos with metadata. This is the long tail —
less structured but potentially very high value (old journals, letters, early writing).
Delegate to the archive-crawler skill. It handles:
Crawling directory structures
Filtering for high-value content (user's own writing, not installers)
Text extraction from PDFs, images (OCR), documents
Entity extraction and brain page creation
Safety gate: Archive crawling can be slow and create many pages.
archive-crawler is a skill, not a CLI command — it refuses to run without an
explicit archive-crawler.scan_paths: allow-list in gbrain.yml. Add the
archive path to the allow-list, run the skill's scan pass first, and show the
user the manifest before proceeding with full ingestion.
Supported sources:
Local directories (Dropbox sync folder, Google Drive, old hard drives)
Cloud storage (Backblaze B2, S3) via mounted paths
Email archives (PST, mbox, EML, Google Takeout)
Data exports (LinkedIn, Facebook, etc.)
Phase 8: Meeting Transcripts
Deep relationship context from recorded calls. If the user has a meeting
recording service (Circleback, Otter, Fireflies, Read.ai), import recent
transcripts.
Delegate to meeting-ingestion skill. Key rules:
Always pull the complete transcript, not just the AI summary
Entity propagation is MANDATORY — every attendee gets a timeline update
A meeting is NOT fully ingested until all entity pages are updated
Post-Bootstrap Checklist
After completing available phases:
Verify brain health:
gbrain doctor --json
gbrain stats
Test retrieval:
gbrain query "who do I meet with most often?"
gbrain query "what am I working on?"
gbrain search "<person from contacts>"
Set up live sync (if not already):
Calendar: daily cron
Email: periodic sweep (4-8 hours)
X: daily ingest
Brain repo: gbrain sync --repo <path> every 5-30 minutes
"Your brain has N pages across people, calendar, email, and conversations.
Live sync is configured for [sources]. From here:
The signal-detector captures entities from every conversation
The briefing skill can compile daily context
The daily-task-prep skill handles day planning
Say 'enrich [person]' to deep-dive any contact"
Anti-Patterns
Giving the agent raw OAuth tokens. This is the #1 anti-pattern. An agent with
raw Gmail/Calendar tokens is an uncontrolled attack surface — one prompt injection
and your entire Google account is exposed. Use ClawVisor. If the user declines
ClawVisor, skip to offline imports. Never offer direct OAuth as a fallback.
Bulk importing everything without filtering. The brain is for signal, not noise.
Filter out automated senders, marketing emails, utility conversations.
Importing without entity cross-linking. Every import should detect entities and
update existing brain pages. Isolated imports don't compound.
Not gating on user consent. Every phase should be presented as a choice. The user
may not want their DMs or therapy conversations imported.
Importing everything at significance 1. Not every conversation is worth a brain
page. Use the significance scale and skip utility content.
Creating people pages for automated senders. Sentry, GitHub notifications,
newsletter platforms are not people. Filter by the rules in Phase 4.
Resume Protocol
If the session is interrupted:
Read ~/.gbrain/cold-start-state.json
Skip completed phases
Resume from next_phase
The user doesn't have to repeat credential setup or re-import completed sources
Output Format
After each phase:
PHASE N COMPLETE: [source name]
================================
Pages created: N
Pages updated: N
Entities linked: N
Time elapsed: N min
Sample pages:
- people/jane-smith.md (created — 3 emails, 5 meetings)
- companies/acme-corp.md (updated — 2 new employees linked)
Next: Phase N+1 — [description]. Ready to proceed?
Tools Used
search — check for existing pages before creating
query — hybrid search for entity deduplication
get_page — read existing pages for merge decisions
put_page — create and update brain pages
add_link — cross-reference entities
add_timeline_entry — record events on entity timelines
sync_brain — sync changes to the index after each phase
