Onboarding

One paste. Scan first, install only the delta. One browser sign-in part-way through, ≤3 clicks at the end. ~20 min on a Mac that already has Xcode; budget ~45 min on a bare machine (the first Command-Line-Tools download dominates). A fresh Mac, Windows, or Linux laptop becomes a fully provisioned databayt environment — every tool installed, every repo cloned, every agent lane working.

This is the single source of truth for joining databayt. It covers every OS, every agent (Claude Code, Claude Desktop, Antigravity, opencode, Hermes), every dotfile, every external account.

Ran this on a real machine? Hit Report an issue in the footer of any kun.databayt.org page and describe what you saw — what worked, what broke, what to change. It files a GitHub issue (no account-juggling, works mid-install from the browser). See Issue pipeline.

The one-liner

Paste in a terminal. The wizard takes over.

macOS / Linux

Copycurl -fsSL https://kun.databayt.org/install | bash

Windows (PowerShell or cmd.exe)

Copypowershell -ExecutionPolicy Bypass -Command "iwr https://kun.databayt.org/install.ps1 | iex"

The bootstrap URL auto-detects your OS and dispatches to the right installer. No need to pick. Re-run anytime — it auto-resumes from where it left off via a state file.

Scan first

Before anything installs, the wizard prints a scan of what's already on the machine — versions, launchers, config — and only installs the delta. Already-provisioned machines sail through with 1–2 dialogs:

Scan — system
  ✓ os               Darwin arm64 (26.4)
  ✓ brew             Homebrew 6.0.1
  ✓ node             v24.13.0
  ✓ gh               gh version 2.83.1

Scan — agents
  ✓ claude           2.1.206 (Claude Code)
  ✓   alias c        bypass launcher
  ✓ claude desktop   app + MCP config
  ✓ agy              1.0.14
  ○ opencode         1.17.13 · bypass config not set
  ○ hermes           not installed (optional gateway)
  ✓ ~/.claude        engine installed

Run the scan alone anytime (changes nothing):

Copybash ~/kun/.claude/scripts/onboarding-mac.sh --detect-only     # scan table
bash ~/kun/.claude/scripts/onboarding-mac.sh --dry-run         # what a run would install
bash ~/kun/.claude/scripts/onboarding-mac.sh --doctor          # scan + full health audit + fix hints

--doctor is the diagnostics mode (Windows: -Doctor): the scan table, then the full engine health audit (health.sh), then a targeted fix hint for every red row — missing lane, config drift, stale heartbeat, dead browser MCP. It diagnoses everything and changes nothing.

The agents

Five lanes, one launcher letter each — pick which to install in the wizard's multi-select (default: all):

The launchers live in one managed block in ~/.zshrc / ~/.bashrc (# BEGIN databayt agents … # END databayt agents) — idempotent across re-runs; legacy function c lines migrate in automatically.

What you get

Running the bootstrap line leaves your machine fully provisioned. Here's what lands, how to verify it, and how to change what's delivered.

Deliverables

Verify what you got

Run these to confirm each layer — all green means fully provisioned:

bash ~/.claude/scripts/health.sh is the authoritative config gate (it audits ~/.claude/ only — pair it with the other rows for a full check). The daily maintain heartbeat posts your status to the team's Config Health Dashboard issue automatically (databayt/kun, label config-health); --report posts it manually.

Modify what's delivered

Want a different result? Edit the source, then re-run the bootstrap (idempotent):

All installer scripts live in ~/kun/.claude/scripts/. Print any backend's flags with no args (e.g. bash ~/kun/.claude/scripts/onboarding-mac.sh).

Every machine is a full autonomous worker

Config is universal — the machine, not the person, is the unit of capability. Every machine gets all agents, all skills, the full MCP fleet (~18), all hooks, and the entire org's repos. Any machine can run any task. Your role is just a label + a secrets-trust tier — it does not limit what your computer can do.

What still varies (and why):

• Secrets — scoped by which Gist you're handed, not by config. A machine only holds the keys it's trusted with; an MCP server without its key simply doesn't connect (harmless). Full config everywhere, contained blast radius.
• Linux — Claude Desktop doesn't exist on Linux; surfaces are the CLI, claude.ai/code in the browser, and the IDE plugins. A Linux box with those is complete — don't expect the Chat/Cowork/Code tabs.
• No Pro/Max — Desktop tabs are unavailable; Claude Code can still bill through an ANTHROPIC_API_KEY, or upgrade for the Desktop surfaces.

Two paths

Pick the one that fits. A fully manual, step-by-step path is at the bottom for auditing or learning the parts.

Neither needs Pro/Max.

The wizard — three acts

Three acts. Most is silent; you click only when a human is unavoidably needed. The one unavoidable pause is a browser sign-in to GitHub part-way through (Act 2, Phase 3).

Act 1 — Pre-flight (~30 seconds, usually 1–2 dialogs)

The wizard scans first and auto-answers what detection can settle; it dialogs only the rest. On a bare machine that's five questions; on a machine with any history it's usually just the agents pick.

All answers persist in a state file. Re-runs skip questions already answered.

What's no longer asked (and why):

Act 2 — Silent batch (~15–40 minutes, progress notifications)

Eight phases run back-to-back. You can minimize the terminal — the wizard fires native OS notifications as each phase advances. One phase is not silent: Phase 3 opens your browser for a GitHub sign-in (the device code is auto-copied to your clipboard) and waits for you to approve.

Each phase emits PROGRESS:N/8:label to stderr; wrappers parse it and fire a native notification (Mac osascript, Linux zenity, Windows NotifyIcon).

Act 3 — Manual finishing (~3 clicks)

Auto-polling OAuth means the only manual clicks left are:

VS Code extension (code --install-extension), GitHub OAuth (--web polls), and Anthropic CLI OAuth (claude first-run polls) are all 0 clicks. Each action button is a deep link that drops you exactly where you need to act — Desktop, WebStorm, or the GitHub device page — on your OS.

Before you sit down — admin checklist

What the inviter must grant or hand over before paste-time:

• GitHub — invite to the databayt org (Phase 3 hard-gates on membership; without it the install can't clone private repos)
• Anthropic account — Pro/Max sub for the full Desktop + CLI experience, or an API key if not on Pro/Max
• Anthropic mobile app — installed + signed in with the same account (native PushNotification from Claude Code)
• Secrets Gist ID — handed out-of-band; powers ~/.claude/.env (MCP keys + cross-cutting tokens). See Secrets.
• Vercel — team invite to databayt (every role) — needed for vercel env pull to populate per-product .env
• Neon — project access for any product whose DATABASE_URL_* you'll touch (engineer)
• Slack — invite to databayt-sh (invite link)
• CRM — login <name>@databayt.org works on all 4 workspaces (see CRM)
• AWS IAM — hogwarts-s3-uploader keys (engineer only)

If something's missing the wizard skips that step and lists it under "things to do later" at the end.

Which repos you get

Every machine clones the full databayt org to your chosen directory (~/, ~/databayt/, or custom) — any machine can touch any repo:

kun (engine config), hogwarts (multi-tenant LMS), codebase (patterns, agents, blocks), shadcn (UI library), radix (UI primitives), souq (e-commerce), mkan (rentals), shifa (medical), ios-app (iOS/Swift), android-app (Kotlin), crm (self-hosted CRM), distributed-computer (infra), marketing (landing pages).

Pick a custom directory and the wizard symlinks ~/kun, ~/hogwarts, etc. back to it so tooling that hard-codes ~/kun keeps working. To clone only the essentials (kun, hogwarts, codebase): pass --essentials-only (Mac/Linux) or -EssentialsOnly (Windows).

The Claude surfaces

After install you have seven Claude surfaces, each with a sweet spot:

Cowork and Claude Code share ~/.claude/ — same brain, two modes; handoff happens via ~/.claude/bridge.md + GitHub Issues. See Cowork ↔ Code. Desktop's three tabs share the CLI's MCP fleet because the wizard symlinks claude_desktop_config.json → ~/.claude/mcp.json.

The other lanes. Beside Claude Code sit three more agents (see The agents): Antigravity (a) — Google's terminal agent wired to the same MCP fleet/skills/playbook via ~/.gemini/, the fallback + cheap lane (full detail: Antigravity); opencode (o) — open-source terminal agent, tertiary; and Hermes (h) — the optional chat-app gateway, Slack-wired (full detail: Hermes). Keep architecture and complex work on c.

Away from the keyboard

Install the Claude mobile app (iOS · Android) and sign in with the same Anthropic account — projects, conversations, and Cowork sessions follow you everywhere. No Tailscale, no extra services; the native primitives cover remote work:

WebStorm settings sync

Share team-standard editor settings: WebStorm → account icon → Sign in to your JetBrains Account → Settings → Backup and Sync → Enable Settings Sync. Recommended scope: code style, inspection profiles, live templates, plugins, keymaps (skip system settings). Settings then follow you to any machine where you sign in to the same account.

Script path (engineer)

Skip the wizard and run the silent backend directly:

Copy# Mac
git clone https://github.com/databayt/kun.git ~/kun && \
  bash ~/kun/.claude/scripts/onboarding-mac.sh engineer <GIST_ID>
 
# Linux
git clone https://github.com/databayt/kun.git ~/kun && \
  bash ~/kun/.claude/scripts/onboarding-linux.sh engineer <GIST_ID>
 
# Windows (PowerShell)
git clone https://github.com/databayt/kun.git $env:USERPROFILE\kun
& $env:USERPROFILE\kun\.claude\scripts\onboarding-windows.ps1 -Role engineer -GistId <GIST_ID>

Useful backend flags (Mac + Linux):

PowerShell equivalents: -Quiet, -GitName, -GitEmail, -ReposDir, -EssentialsOnly, -HogwartsDev. Re-run anytime; idempotent.

Manual path

For auditing what gets installed, or if both other paths fail — the full per-OS step-by-step lives in two focused docs:

• Claude Code — per-OS side-tools, Claude Code CLI, the c launcher, GitHub SSH auth, and troubleshooting.
• Antigravity — the secondary agent: agy install, the a launcher, and the ~/.gemini/ bridge to the shared MCP fleet / skills / playbook.
• Secrets — Gist-based ~/.claude/.env provisioning and vercel env pull for per-product .env.

For hogwarts, your team contact shares the .env out-of-band — there is no .env.example.

Daily entry points

Full keyword list: keywords.

Day 2 — the machine supervises itself

After setup, every machine runs a daily maintain heartbeat (09:17 local — macOS launchd com.databayt.kun-maintain · Windows Scheduled Task kun-maintain · Linux cron). You never re-install or chase updates by hand; the machine does:

1. Pull ~/kun (main only; skips if you're mid-rebase or offline; aborts cleanly on conflict — never leaves the tree broken)
2. Refresh ~/.claude — setup.sh --quiet re-copies agents/skills/rules/settings/MCP from the fresh source and prunes engine items removed upstream
3. Health-check — full health.sh audit + a disk-space floor
4. Record — state to ~/.claude/.kun-maintain.json (cat it anytime)
5. Report — posts to the team's Config Health Dashboard weekly, and immediately if health goes RED

If the heartbeat goes stale (>48h) or health is RED, a warning surfaces automatically at the start of every Claude Code session — in any project, not just kun. What each warning means:

Personal vs engine-managed config

The heartbeat re-copies engine config daily — so know which files are yours:

Personal items survive by construction: the pruner only deletes what the engine's manifest (~/.claude/.kun-manifest.json) says the engine itself shipped.

Auto-resume

The wizard persists every choice to a state file so re-runs skip what's done:

To reset and start fresh: delete the state file, then re-run the bootstrap.

Troubleshooting

For anything else, file an issue at https://github.com/databayt/kun/issues.

Where to go next

This page is the front door. Once your machine is provisioned, branch out:

Set up & verify

• Claude Code — CLI install detail + config
• MCP — the server fleet + /mcp-doctor recovery
• Secrets — Gist-based provisioning
• Self-hosting — tmux / Docker (optional)

Daily use

• Keywords — one word → a workflow
• Captain — decisions, delegation, the weekly rhythm
• Cowork ↔ Code — same brain, two modes

Understand the engine

• Configuration — universal-config blueprint
• Architecture — the 5 layers
• Agents — the agent fleet
• Team — the humans + roles

Contribute

• Issue pipeline — "Report an issue" → GitHub → optional auto-fix
• Repositories — full org map
• Contributing — issue → branch → PR → merge

External

• Apps · Connectors · Anthropic Directory