Jeeves Client Deployment Strategy
Multi-Instance Architecture

Jeeves = Hermes Profile Clone. Same Engine. Different Soul.

Each Jeeves instance is a named Hermes profile — a complete, isolated directory at:

~/.hermes/profiles/<client-slug>/

The profile contains everything needed to run an independent agent: config, credentials, persona, skills, memory, sessions, OAuth tokens. Multiple profiles can run simultaneously with no interference. Robert runs two right now: default (his orchestration agent) and jeeves-robert (his personal chief of staff).

How Cloning Actually Works (Confirmed from CLI)

hermes profile create NAME --clone-from SOURCE [flags]

Three clone modes exist:

What --clone ACTUALLY copies from source:

• config.yaml — model settings, gateway port config, agent settings
• .env — API keys and platform tokens (this includes the Anthropic key!)
• SOUL.md — persona file

What --clone does NOT copy:

• skills/ — empty skill library (or bundled defaults only)
• memory/ — fresh MEMORY.md and USER.md
• auth.json — fresh credential pool (no OAuth tokens)
• sessions/ — blank session history

What --clone-all additionally copies:

• skills/ — the full skill library from source
• memory/ — all memory files (NOT recommended for clients)
• Sessions and other state

What's Shared vs Per-Client

The Port Map (Current and Planned)

The solution to "20 minutes not 4 hours" is a master template profile called jeeves-template. You create it once, perfect it, and every new client clones from it. The template has everything pre-configured except the three client-specific items.

What Goes in the Template

config.yaml — pre-configured:

model:
  default: claude-sonnet-4-6
  provider: anthropic
agent:
  max_turns: 50
  gateway_timeout: 1800
  dispatch_in_gateway: true
  name: Jeeves    # overridden per client
gateway:
  port: XXXX      # overridden per client

SOUL.md — a generic Jeeves template:

The Wodehouse/Carson archetype with placeholder sections for [CLIENT_NAME], [CLIENT_BUSINESS], [CLIENT_CONTEXT], and skills/domains this instance has access to.

.env — intentionally empty placeholders:

# FILL IN: Client's own Anthropic API key
ANTHROPIC_API_KEY=

# FILL IN: Client's dedicated Telegram bot token (from @BotFather)
TELEGRAM_BOT_TOKEN=

# FILL IN: Client's Telegram user ID (from @userinfobot)
TELEGRAM_HOME_CHANNEL=
TELEGRAM_ALLOWED_USERS=

# PRE-CONFIGURED: Shared infrastructure (Robert's, not client-specific)
# These remain blank — each client brings their own
NOTION_API_KEY=
SUPABASE_URL=
SUPABASE_KEY=

skills/ — the full Jeeves skill library pre-installed:

• Core productivity: google-workspace, notion, airtable
• Research: arxiv, web, competitive-intelligence-analysis
• Content: copywriting, social-content, email-sequence
• Operations: agency-pm-methodology, linear
• Meta: hermes-agent, systematic-debugging
• Jeeves-specific: The jeeves/ skill category with chief-of-staff playbooks

memories/MEMORY.md — bootstrap context:

# Client Context

## Business
- Name: [CLIENT_NAME]
- Industry: [INDUSTRY]
- Core goal: [GOAL]
- Key contacts: [CONTACTS]

## Preferences
- Communication style: [STYLE]
- Escalation rules: [RULES]
- Priority domains: [DOMAINS]

What to Leave Blank in the Template

• ANTHROPIC_API_KEY — client provides their own
• TELEGRAM_BOT_TOKEN — create new via @BotFather per client
• TELEGRAM_HOME_CHANNEL / TELEGRAM_ALLOWED_USERS — client's Telegram user ID
• auth.json OAuth tokens — client must authorize via OAuth flow
• SOUL.md client-specific sections — filled during onboarding
• gateway.port — assigned from port registry

How to Maintain the Template

The template is a living artifact. When Robert discovers a better Jeeves pattern:

1. Update ~/.hermes/profiles/jeeves-template/SOUL.md
2. Install new skills: hermes -p jeeves-template skills install [skill-name]
3. Update template config.yaml settings
4. Do NOT update deployed client instances automatically — changes propagate on next manual client update

Keep a TEMPLATE-CHANGELOG.md in the template profile directory noting what changed and why.

The Three Things That MUST Be Client-Specific

1. Telegram bot token — unique per client (create via @BotFather, 2 minutes)
2. Anthropic API key — client's own account (they create it, Robert enters it)
3. SOUL.md — the persona and business context (generated from intake form output)

The 20-Minute Onboarding Sequence

Before the session (client's homework, ~5 minutes):

• Client creates an Anthropic account and generates an API key
• Client downloads Telegram and creates an account
• Client fills out 16Fold intake form (business context, communication style, domains)

During onboarding (Robert, ~15 minutes):

NEXT_PORT=8644
CLIENT_SLUG=clientname-company
hermes profile create $CLIENT_SLUG --clone-from jeeves-template

hermes -p $CLIENT_SLUG config set gateway.port $NEXT_PORT

hermes -p $CLIENT_SLUG config env-path
# Then manually edit to add: ANTHROPIC_API_KEY=<client key>

# Add to the profile's .env:
TELEGRAM_BOT_TOKEN=<token from @BotFather>
TELEGRAM_HOME_CHANNEL=<client's telegram user ID>
TELEGRAM_ALLOWED_USERS=<client's telegram user ID>

cp /path/to/intake-output/SOUL.md ~/.hermes/profiles/$CLIENT_SLUG/SOUL.md

# Edit: ~/.hermes/profiles/$CLIENT_SLUG/memories/MEMORY.md

./create-jeeves-client.sh $CLIENT_SLUG $NEXT_PORT

hermes -p $CLIENT_SLUG gateway start
hermes -p $CLIENT_SLUG gateway status
# Confirm: bot appears online in Telegram

hermes -p $CLIENT_SLUG setup gateway
# Client authorizes Gmail and Calendar via OAuth flow in browser

What's Automatic vs Manual

1. API Key (Client's Own Anthropic Account)

Every client MUST have their own Anthropic account and API key. This is non-negotiable:

• Protects Robert from runaway spend from one client burning his key
• Gives clients visibility into their own usage and costs
• Allows Robert to tier by model (Haiku for Tier 1, Sonnet for Tier 2, Opus for Tier 3)

Location: ~/.hermes/profiles/<client>/.env → ANTHROPIC_API_KEY

2. Telegram Bot Token (Unique Per Client)

Each client gets their own dedicated Telegram bot via @BotFather. This means:

• Clients message their own bot, not Robert's
• Robert's bot never sees client traffic
• Bots can have client-branded names (e.g., "Jeeves for Acme Corp")

Location: ~/.hermes/profiles/<client>/.env → TELEGRAM_BOT_TOKEN

TELEGRAM_HOME_CHANNEL=<client's telegram user ID>
TELEGRAM_ALLOWED_USERS=<client's telegram user ID>

3. SOUL.md (Persona + Client Business Context)

The SOUL.md is what makes each Jeeves instance feel like IT knows THIS client's business. It should include:

• Identity section: Name: Jeeves, Wodehouse/Carson archetype, owner name and role
• Business context: Company name, industry, size, goals, active clients, revenue targets, team structure
• Communication rules: Preferred style, what to escalate vs handle autonomously, banned topics
• Tools and domains: Which skills are installed, which OAuth connections are wired, which MCP servers are configured

4. Client Knowledge Base

Option A — Skills (best for playbooks and SOPs):

Create a clients/<client-name>/ skill category with brand guidelines, content rules, product knowledge, key processes.

Option B — Memory (best for context and relationships):

Pre-populate memories/MEMORY.md with business overview, key contacts, current priorities, historical context.

Option C — AGENTS.md (best for operational rules):

Place an AGENTS.md in the profile directory with current projects, team structure, infrastructure details, non-negotiable rules.

Option D — Session documents (best for reference docs):

Upload client PDFs/docs to Google Drive and configure the profile's SOUL.md to point Jeeves there.

5. OAuth Connections (Per-Client Authorization)

Gmail + Calendar (Google OAuth):

hermes -p <client> setup gateway
# Select Google → follow OAuth flow
# Saves token to: ~/.hermes/profiles/<client>/google_token.json

Notion (API key, not OAuth):

NOTION_API_KEY=<client's integration token>

Client must share their Notion workspace with the Notion integration.

6. Memory Initialization

# MEMORY.md — operational memory

## Business Context
[From intake form — company, goals, current priorities]

## Key Relationships
[Team members, clients, stakeholders, vendors]

## Preferences
[Communication style, escalation rules, scheduling preferences]

## Infrastructure
[Tools used: Gmail, Notion, etc. Key URLs and accounts]

## Current Projects
[Active work items and their status]

7. Skills (Tier-Based Skill Sets)

What Are GEO Agents?

GEO agents are add-on modules for clients with location-based business needs:

Most likely definition — Local Search / Google Business Profile monitoring:

• Monitor and respond to Google Business Profile reviews
• Track local SEO rankings (position by keyword + location)
• Monitor local competitor activity
• Alert on NAP (Name/Address/Phone) inconsistencies
• Automate GBP post scheduling

Secondary definition — Multi-location business intelligence:

• Aggregate performance across multiple locations
• Location-specific content variants
• Regional trend monitoring

GEO agents would be implemented as:

1. Hermes cron jobs within the client's profile that run nightly
2. Skills with location-specific playbooks
3. n8n workflows that feed intelligence into Hermes memory
4. Webhook triggers from Google API → Hermes for real-time alerts

16Fold Vertical Agents

~/.hermes/profiles/<client>/skills/vertical/
  jeeves-agency/SKILL.md
  geo-local-seo/SKILL.md
  geo-gbp-monitor/SKILL.md

Feature Flag Architecture (Tier Gating)

Since Hermes doesn't have a native feature flag system, gating is implemented at three levels:

Level 1 — Skills not installed:

Simply don't install the skill in the profile. If the skill isn't there, Hermes can't use it. This is the cleanest gate.

Level 2 — SOUL.md restrictions:

## Capabilities (Tier 2 Professional)
You have access to: [list of enabled skills]
You do NOT have access to: [list of locked features]
If a client requests a locked feature, respond: "That capability is available on the Enterprise tier."

Level 3 — Config-level tool disabling:

agent:
  disabled_toolsets: [delegation, cronjob]  # Lock out agent spawning for Tier 1

Tier gate summary:

The Problem Tonight

When jeeves-robert was created, it launched with:

• ✅ config.yaml (cloned from default)
• ✅ SOUL.md (Jeeves persona)
• ✅ .env with Anthropic key (cloned)
• ❌ No Crabtree skills (the 100+ crabtree/ skills don't exist in the profile)
• ❌ No MCP servers (supabase, n8n, notion, council, higgsfield not configured)
• ❌ No Gmail/Calendar OAuth (fresh auth.json)
• ❌ No vault access wired
• ❌ Memory is blank

How to Fix jeeves-robert Tonight (Priority Order)

1. Copy Crabtree skills → fills the biggest capability gap immediately
2. Add env vars → enables MCP servers and tool integrations
3. Configure MCP servers → connects to Supabase, n8n, Notion
4. Copy AGENTS.md → gives Jeeves the operational context
5. Bootstrap MEMORY.md → pre-populate with Robert's context
6. Re-authorize Google OAuth → Gmail and Calendar access
7. Test with a real task → verify vault search, morning briefing, task routing

Skills — must be installed:

cp -r ~/.hermes/skills/crabtree ~/.hermes/profiles/jeeves-robert/skills/

MCP Servers — must be configured:

hermes -p jeeves-robert mcp add supabase --command "npx" --args "-y @supabase/mcp-server-supabase"
hermes -p jeeves-robert mcp add n8n --url "https://n8n-crabtree-u66840.vm.elestio.app/mcp"
hermes -p jeeves-robert mcp add notion --command "npx" --args "-y @notionhq/notion-mcp-server"
hermes -p jeeves-robert mcp add council --command "hermes-council-server"

Environment variables — must be in .env:

SUPABASE_URL=<same as default>
SUPABASE_KEY=<same as default>
SUPABASE_SERVICE_KEY=<same as default>
N8N_API_KEY=<same as default>
NOTION_API_KEY=<same as default>
OPENROUTER_API_KEY=<same as default>
GITHUB_TOKEN=<same as default>
CLOUDFLARE_API_TOKEN=<same as default>

AGENTS.md — add to profile:

cp ~/.hermes/AGENTS.md ~/.hermes/profiles/jeeves-robert/AGENTS.md

Key skills for jeeves-robert:

• vault-semantic-search — so Jeeves can query CLAUDEVAULT
• morning-briefing-data-sources — for daily briefings
• ground-in-vault-before-strategy — before any strategic work
• single-pane-of-glass-for-robert — surface all pending work
• drowning-recovery-sweep — when Robert is overwhelmed
• surface-on-decisions-dashboard — pending decisions
• google-workspace — Gmail + Calendar operations
• All the V4 agent skills (for routing to Porter, Ogilvy, etc.)

How Many Clients Can Mac Studio Handle?

Hardware: Mac Studio M4 Pro, 48GB RAM

Per-profile resource estimate:

• Idle gateway process: ~50–100MB RAM
• Active conversation: ~200–400MB additional RAM
• Skills loaded: ~50MB per active session
• MCP servers: ~50–100MB per server (shared if same server)

Port Allocation Strategy

Port registry — maintain at ~/.hermes/jeeves-port-registry.json:

{
  "8642": {"profile": "default", "client": "Robert Crabtree (Orchestrator)", "active": true},
  "8643": {"profile": "jeeves-robert", "client": "Robert Crabtree (Jeeves)", "active": true},
  "8644": {"profile": "acme-corp", "client": "Acme Corp", "active": false}
}

LaunchAgent Pattern Per Client

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "...">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>ai.hermes.gateway.CLIENT_SLUG</string>

    <key>EnvironmentVariables</key>
    <dict>
        <key>HERMES_HOME</key>
        <string>/Users/robert/.hermes/profiles/CLIENT_SLUG</string>
    </dict>

    <key>StandardOutPath</key>
    <string>/Users/robert/.hermes/profiles/CLIENT_SLUG/logs/gateway.log</string>
</dict>
</plist>

Key difference from default plist: Label is unique per client, HERMES_HOME points to the profile directory, and logs go to the profile's own log directory.

Monitoring: How Robert Knows If a Bot Is Down

Method 2 — Watchdog script (recommended):

#!/bin/bash
# check-jeeves-clients.sh
while IFS= read -r profile; do
    STATUS=$(hermes -p $profile gateway status 2>&1)
    if [[ "$STATUS" != *"running"* ]]; then
        # Alert Robert via Telegram
        curl -s -X POST "https://api.telegram.org/bot$ROBERT_BOT_TOKEN/sendMessage" \
             -d "chat_id=$ROBERT_CHAT_ID&text=⚠️ Jeeves gateway DOWN: $profile"
        # Attempt restart
        hermes -p $profile gateway start
    fi
done < /Users/robert/.hermes/active-jeeves-profiles.txt

Recommended: Method 2 (centralized watchdog) via a cron job in Robert's default profile, running every 30 minutes.

When to Move to Cloud (Tier 3 Recommendation)

Move to cloud when:

• ≥15 active concurrent client gateways
• Monthly Jeeves revenue ≥ $15,000/month
• Any single client needs >99.5% uptime SLA
• A client is international (need low-latency regions)
• Robert starts losing sleep over Mac Studio going down

Cloud architecture for Tier 3:

• Each client profile becomes a Docker container
• Deploy to Railway, Fly.io, or DigitalOcean
• Profile directory = persistent volume mount
• Container image = Hermes base + profile overlay

Migration path:

1. hermes profile export CLIENT_SLUG → creates CLIENT_SLUG.tar.gz
2. Move to cloud VM
3. hermes profile import CLIENT_SLUG.tar.gz
4. Update Telegram webhook URL if needed
5. Decommission Mac Studio instance for that client

#!/bin/bash
# create-jeeves-client.sh
# Usage: ./create-jeeves-client.sh <client-slug> <client-name> <bot-token> <anthropic-key> <telegram-user-id>
# Example: ./create-jeeves-client.sh acme-corp "Acme Corporation" 7123456:AAxx... sk-ant-... 123456789

set -euo pipefail

CLIENT_SLUG="$1"
CLIENT_NAME="$2"
BOT_TOKEN="$3"
ANTHROPIC_KEY="$4"
TELEGRAM_USER_ID="$5"

HERMES_HOME="/Users/robert/.hermes"
PROFILES_DIR="$HERMES_HOME/profiles"
TEMPLATE_PROFILE="jeeves-template"
PLIST_DIR="$HOME/Library/LaunchAgents"
PORT_REGISTRY="$HERMES_HOME/jeeves-port-registry.json"
ROBERT_CHAT_ID="6722461724"

echo "🎩 Creating Jeeves instance for: $CLIENT_NAME"

# STEP 1: Find next available port
NEXT_PORT=$(python3 -c "
import json
with open('$PORT_REGISTRY') as f:
    registry = json.load(f)
used = [int(p) for p in registry.keys()]
port = 8644
while port in used:
    port += 1
print(port)
")

# STEP 2: Clone from master template
hermes profile create "$CLIENT_SLUG" --clone-from "$TEMPLATE_PROFILE"
cp -r "$PROFILES_DIR/$TEMPLATE_PROFILE/skills" "$PROFILES_DIR/$CLIENT_SLUG/"

# STEP 3: Set the gateway port
hermes -p "$CLIENT_SLUG" config set gateway.port "$NEXT_PORT"

# STEP 4: Write the .env file
cat > "$PROFILES_DIR/$CLIENT_SLUG/.env" << EOF
ANTHROPIC_API_KEY=$ANTHROPIC_KEY
TELEGRAM_BOT_TOKEN=$BOT_TOKEN
TELEGRAM_HOME_CHANNEL=$TELEGRAM_USER_ID
TELEGRAM_ALLOWED_USERS=$TELEGRAM_USER_ID
EOF

# STEP 5: Install SOUL.md
SOUL_SOURCE="/tmp/jeeves-intake-$CLIENT_SLUG-SOUL.md"
if [[ -f "$SOUL_SOURCE" ]]; then
    cp "$SOUL_SOURCE" "$PROFILES_DIR/$CLIENT_SLUG/SOUL.md"
else
    sed -i '' "s/\[CLIENT_NAME\]/$CLIENT_NAME/g" "$PROFILES_DIR/$CLIENT_SLUG/SOUL.md"
fi

# STEP 6: Bootstrap memory
MEMORY_FILE="$PROFILES_DIR/$CLIENT_SLUG/memories/MEMORY.md"

# STEP 7: Create LaunchAgent plist
PLIST_FILE="$PLIST_DIR/ai.hermes.gateway.$CLIENT_SLUG.plist"
# [plist content generated here — see Section 7]

# STEP 8: Load gateway
mkdir -p "$PROFILES_DIR/$CLIENT_SLUG/logs"
launchctl load "$PLIST_FILE"

# STEP 9: Register in port registry
python3 -c "
import json
from datetime import datetime
with open('$PORT_REGISTRY') as f:
    registry = json.load(f)
registry['$NEXT_PORT'] = {
    'profile': '$CLIENT_SLUG',
    'client': '$CLIENT_NAME',
    'active': True,
    'created': '$(date -u +%Y-%m-%dT%H:%M:%SZ)'
}
with open('$PORT_REGISTRY', 'w') as f:
    json.dump(registry, f, indent=2)
"

# STEP 10: Add to active profiles list
echo "$CLIENT_SLUG" >> "$HERMES_HOME/active-jeeves-profiles.txt"

# STEP 11: Ping Robert via Telegram
echo "✅ Jeeves instance created! Profile: $CLIENT_SLUG | Port: $NEXT_PORT"

Key Script Notes

What the script handles automatically:

• Port allocation from registry
• Profile creation from template (via --clone-from)
• .env file with client's credentials
• SOUL.md installation (from intake file or template fallback)
• Memory bootstrap (from intake file or minimal stub)
• LaunchAgent plist generation with correct HERMES_HOME
• Service loading and gateway start
• Port registry update + active profiles list update
• Telegram ping to Robert with status and remaining tasks

What still requires human action:

• Creating the Telegram bot via @BotFather (3 clicks, 2 minutes)
• Getting the client's Anthropic API key (client does this)
• Gmail/Calendar OAuth authorization (client must click through browser)
• Custom SOUL.md if intake form isn't used (Robert reviews)
• MCP server configuration if client uses non-standard tools

File Structure of a Client Profile

~/.hermes/profiles/<client-slug>/
├── config.yaml              # Model, gateway port, agent settings
├── .env                     # API keys, bot token, Telegram config
├── SOUL.md                  # Persona and business context
├── AGENTS.md                # Operational context (optional but recommended)
├── auth.json                # OAuth credential pool (empty until authorized)
├── google_token.json        # Google OAuth token (after authorization)
├── skills/                  # Skill library (copied from template)
│   ├── .bundled_manifest
│   ├── google-workspace/
│   ├── notion/
│   └── [tier-appropriate skills]
├── memories/
│   ├── MEMORY.md            # Operational memory (bootstrapped from intake)
│   └── USER.md              # User profile (built by Hermes over time)
├── sessions/                # Session transcripts (starts empty)
├── logs/
│   ├── gateway.log          # Gateway stdout
│   └── gateway.error.log    # Gateway stderr
└── platforms/               # Platform adapter configs

Commands Robert Uses Daily

# See all Jeeves instances
hermes profile list

# Check a specific client's status
hermes -p acme-corp gateway status

# Start a stopped gateway
hermes -p acme-corp gateway start

# Stop a gateway (e.g., client churned)
hermes -p acme-corp gateway stop

# Update a client's SOUL.md
nano ~/.hermes/profiles/acme-corp/SOUL.md

# Install a new skill to a client
hermes -p acme-corp skills install [skill-name]

# Check a client's logs
tail -f ~/.hermes/profiles/acme-corp/logs/gateway.log

# See all active gateways
for p in $(cat ~/.hermes/active-jeeves-profiles.txt); do
  echo "$p: $(hermes -p $p gateway status 2>&1 | grep -o 'running\|stopped')"
done

The 3 Non-Negotiable Per-Client Items

1. TELEGRAM_BOT_TOKEN — Created via @BotFather. Unique per client. Takes 2 minutes.
2. ANTHROPIC_API_KEY — Client's own Anthropic account key. Never use Robert's key for clients.
3. SOUL.md — The persona file with client's business context. Generated from intake form or crafted manually.

Everything else can be templated, scripted, or done later.

This document reflects actual Hermes capabilities as of May 13, 2026 based on live inspection of Robert's installation. Hermes version in use: source install at /Users/robert/work/agents/hermes-agent. Profile system confirmed via hermes profile create --help.