Personal Super AI System Setup Guide: MacBook + Mac mini + Codex + Lobster + Tailscale = Your Own Personal Super AI System

I. What Problem Does This System Actually Solve

This system solves just one problem: building a personal super AI system that belongs to you.

This is not simply installing a few pieces of software. Instead, it clearly divides the roles of hardware and software components and integrates them into an organic whole.

This organic system is functional, easy to use, works for productivity and leisure, and truly becomes a personal super AI system.

Work MacBook: The daily operation entry point.
You use the MacBook at work, outside, or at home for projects, documents, coding, remote login to Mac mini, and task control.

Home Mac mini: The always-on AI workhorse.
It runs Codex App, Codex CLI, OpenClaw/Lobster gateway, various long-running tasks, skills, scripts, and automation.

Codex: The real agent execution layer.
From now on, Codex will be the primary tool to read projects, modify files, run commands, generate skills, maintain code, and package projects.

Lobster / OpenClaw: The gateway and memory layer.
It handles Feishu, WeChat, scheduled tasks, message ingress, session memory, and old agent workflows. In the future, it won’t be the main agent but more of a “message gateway + scheduler”. (Lobster is not suitable as the core agent — it’s too unreliable and uncontrollable.)

Tailscale: The secure remote network.
It allows MacBook, iPhone, and Mac mini to access each other as if they were on the same private LAN, without exposing SSH, VNC, or gateway ports to the public internet.

II. Overall System Architecture Diagram

┌────────────────────────────┐
│       Work MacBook         │
│  - Write code / view files │
│  - SSH into Mac mini       │
│  - VS Code / Cursor Remote │
│  - Remote desktop control  │
└─────────────┬──────────────┘
              │
              │ Tailscale Private Network
              │ ssh / vnc / http internal access
              ▼
┌────────────────────────────┐
│       Home Mac mini        │
│  - Always online           │
│  - Codex App               │
│  - Codex CLI               │
│  - OpenClaw / Lobster GW   │
│  - tmux long tasks         │
│  - skills / workspace / git│
└─────────────┬──────────────┘
              │
              │ gateway / webhook / CLI calls
              ▼
┌────────────────────────────┐
│   Feishu / WeChat / GitHub │
│  - Message entry           │
│  - Task trigger            │
│  - Code repository         │
│  - File sync               │
└────────────────────────────┘

One sentence summary:

MacBook is the remote control;
Mac mini is the server room;
Codex is the worker;
Lobster is the receptionist and gateway;
Tailscale is the dedicated line.

After setting up the entire system, it looks like the diagram below:

III. Why Not Let the MacBook Do Everything

The MacBook can do it, but it’s not suitable as a long-term agent host.

Reasons:

First, the MacBook is my work computer — frequently taken away, lid closed, network switched, environment changed. Long-running agent tasks are easily interrupted.

Second, as a work computer, too many tasks create chaos. Writing articles today, debugging code tomorrow, running image generation the day after — the environment easily gets polluted.

Third, the Mac mini can stay at home permanently — not moved, not shut down, not put to sleep. It acts more like your own “small AI server”.

So the final principle is:

MacBook is responsible for issuing commands;
Mac mini is responsible for continuous execution.

IV. Positioning the Mac mini

From now on, the Mac mini will be our Codex dedicated host.

On it, we mainly put:

~/dev/github/           # GitHub project directory
~/dev/lab/              # Temporary experiment directory
~/.codex/               # Codex config, skills, AGENTS.md
~/.openclaw/            # Lobster configuration, workspace, agent, memory
~/.openclaw/workspace/  # Lobster workspace

It is recommended to keep this mindset for the long term:

• Important projects go into GitHub;
• Temporary projects go into lab;
• Codex rules go into ~/.codex;
• Lobster old workflows go into ~/.openclaw;
• Large files do not go into git casually.

V. Step 1: Mac mini Base Environment Setup

1. Install Xcode Command Line Tools

xcode-select --install

This is the foundation for git, compilation tools, and many development dependencies on macOS.

2. Install Homebrew

Run the installation command from the Homebrew official website. After installation, confirm:

brew --version
brew doctor

Then install basic tools (run the command below directly):

brew install git node python uv jq wget tree ripgrep fd tmux

Approximate roles of these tools:

Tool	Purpose
git	Code version control
node	Run frontend, npm, Codex CLI
python	Run scripts
uv	Faster Python package management
jq	Process JSON
wget	Download files
tree	View directory structure
ripgrep	Fast text search
fd	Fast file search
tmux	Keep long-running task sessions alive

VI. Step 2: Install Codex

Codex has three common forms:

• Codex App – GUI, suitable for full project development, browser, Computer Use
• Codex CLI – Terminal agent, suitable for SSH, scripting, automation, file editing
• Codex IDE Plugin – Use directly within Cursor / VS Code

Install Codex CLI:

npm i -g @openai/codex

After installation, run:

codex

First time will prompt for login — use ChatGPT account or API key.

To upgrade:

npm i -g @openai/codex@latest

Codex user-level configuration file:

~/.codex/config.toml

For Codex App, download it from the official website.

VII. Step 3: Install Lobster / OpenClaw

On the Mac mini, install:

npm install -g openclaw@latest

Initialize:

openclaw onboard

Common check commands:

openclaw status
openclaw status --deep
openclaw doctor
openclaw models list
openclaw models status

Start the gateway:

openclaw gateway start

Check gateway status:

openclaw gateway status --deep

View logs:

openclaw logs --follow --local-time

Your Lobster will mainly handle:

1. Feishu / WeChat message ingress
2. Scheduled tasks
3. Old agent memory
4. Gateway forwarding
5. Future calls to codex exec for actual execution

Lobster doesn’t necessarily have to be installed on the Mac mini; it can also be installed on the original Windows computer. For installation, refer to: [Original Lobster Installation Guide: Using Lobster to Drive GPT 5.4 to Work for You]

Lobster related configuration can also be found in the article above.

That is, in the future, Lobster doesn’t have to think on its own or write code itself. A better mode is:

Feishu / WeChat message
    ↓
Lobster gateway receives
    ↓
Parse task
    ↓
Call Codex CLI / skill / script
    ↓
Return result to Feishu / WeChat

System running workflow diagram is shown below:

VIII. Step 4: Install Tailscale

Install Tailscale on both the Mac mini and MacBook.

After installation, log in to the same Tailscale account on both devices.

Then on the Mac mini, look up your Tailscale IP, typically:

100.x.x.x

From now on, when connecting from the MacBook to the Mac mini, do not use the public IP or open router ports. Directly use:

ssh [email protected]

Or:

vnc://100.x.x.x

For now, keep the setup simple:

• Tailscale is responsible for the private network;
• macOS built-in SSH is responsible for login;
• macOS Screen Sharing is responsible for remote desktop.

IX. Step 5: Enable Mac mini Remote Login

On the Mac mini, enable SSH:

sudo systemsetup -setremotelogin on

Test:

ssh [email protected]

Example:

ssh [email protected]

First connection will prompt for fingerprint confirmation, type:

yes

From then on, you can remotely enter the Mac mini terminal.

X. Step 6: Enable Mac mini Screen Sharing

On the Mac mini:

System Settings → General → Sharing → Turn on “Screen Sharing”

It is recommended to allow access only for your own user, not for all users.

Then on the MacBook, open Finder:

Go → Connect to Server

Enter:

vnc://100.x.x.x

This allows you to see the Mac mini desktop remotely.

This channel is suitable for:

1. Using Codex App
2. Needing browser operations
3. Needing Computer Use
4. Needing GUI configuration for software
5. Remote emergency access

The SSH channel is suitable for:

1. Running Codex CLI
2. Editing files
3. Executing commands
4. Viewing logs
5. Running tmux long tasks

Working in the Tailscale network is illustrated below:

XI. Step 7: Prevent Mac mini from Sleeping

The Mac mini must stay on, otherwise agents will disconnect mid-task.

Check current power settings:

pmset -g

Recommended settings:

sudo pmset -a sleep 0 displaysleep 10 disksleep 0 womp 1 tcpkeepalive 1

To temporarily prevent sleep manually, run:

caffeinate -dimsu

A stronger way:

sudo pmset -a disablesleep 1

But this is quite aggressive. It is recommended to confirm stability before using.

You can also set these via the GUI in System Settings.

XII. Step 8: Use tmux to Keep Long-Running Tasks

The biggest problem with SSH: if you disconnect, normal terminal tasks might be lost.

Therefore, you must use tmux on the Mac mini.

Install:

brew install tmux

Create a Codex session:

tmux new -s codex

Inside, run:

codex

Detach without closing the task:

Ctrl + b then press d

Re-attach:

tmux attach -t codex

Common commands:

tmux ls
tmux new -s codex
tmux new -As codex
tmux attach -t codex
tmux kill-session -t codex

Recommended to have several tmux windows on the Mac mini long-term:

• codex – Run Codex CLI
• gateway – Run Lobster gateway / view status
• logs – View openclaw logs
• dev – Run npm / python / skills
• monitor – View htop / system status

The diagram of the whole system centered on Mac mini is shown below:

XIII. Daily Workflow

Scenario 1: At work, using MacBook to control home Mac mini

ssh [email protected]
tmux new -As codex
cd ~/dev/github/your-project
codex

Then directly tell Codex:

Check the project structure, find README, AGENTS.md and package.json, and tell me how to start.

Or:

Based on the current project, my requirement is xxxx. Give me the result directly.

Scenario 2: Use MacBook remote desktop to operate Codex App

Finder → Go → Connect to Server → vnc://100.x.x.x

Then directly open Codex App on the Mac mini.

Suitable for:

1. Viewing GUI
2. Using browser
3. Handling tasks that need Computer Use
4. Remote debugging of web pages
5. Operating complex UI

Scenario 3: Send a task in Feishu, Lobster receives it, then forwards to Codex

The ideal final state is:

You send “Package the WeChat official account skill and sync to GitHub” in Feishu. Feishu bot receives ↓ Lobster gateway determines the task ↓ Enters corresponding workspace ↓ Calls codex exec or skill CLI ↓ Codex modifies files / packages / git commit ↓ Lobster returns result to Feishu

This is the key upgrade direction going forward.

Lobster is no longer the main agent, but:

Message entry + access control + session memory + scheduling layer

Codex is the real worker:

Agent runtime that actually gets things done

XIV. Recommended Directory Structure

On the Mac mini, organize as follows:

mkdir -p ~/dev/github
mkdir -p ~/dev/lab
mkdir -p ~/dev/archive
mkdir -p ~/.codex/skills
mkdir -p ~/.openclaw/workspace

Structure:

~/dev/github/
  wechat-article-pipeline-skill/
  codex-gateway/
  feishu-bridge/
  godot-game-demo/
 
~/dev/lab/
  test-skill/
  test-image-jobs/
  temp-codex-output/
 
~/.codex/
  config.toml
  AGENTS.md
  skills/
 
~/.openclaw/
  openclaw.json
  workspace/
  agents/
  memory/

XV. The Role of AGENTS.md

In the future, every important project should have its own:

AGENTS.md

It serves as the project manual for Codex.

For example, in a WeChat official account skill project:

# AGENTS.md
 
## Project Goal
 
This is a WeChat official account article generation skill.
 
## Work Principles
 
- Prefer output in Markdown + HTML mixed format
- Image generation should not use one style for all images
- Header, middle, and footer images should have different roles
- After code modification, tests must be run
- Check directory structure before packaging
 
## Prohibited Items
 
- Do not commit temporary files to git
- Do not write API keys into the repository
- Do not delete user's original articles

When Codex enters the project, it knows the rules of this project.

XVI. GitHub Workflow

Every important project should go into GitHub.

Basic flow:

cd ~/dev/github/your-project
git status
git add .
git commit -m "update"
git push

If creating a repository for the first time:

git init
git add .
git commit -m "initial commit"
git branch -M main
git remote add origin [email protected]:your-username/repo-name.git
git push -u origin main

It is recommended to write a clear .gitignore:

.DS_Store
node_modules/
.env
.env.local
dist/
build/
tmp/
.cache/

Directories like Lobster workspace that might be large should not be blindly pushed to GitHub.

XVII. Security Principles of This System

1. Do not open public ports

Do not expose these to the public internet:

• SSH 22
• VNC 5900
• OpenClaw gateway
• Local web service debug ports

All go through Tailscale.

2. SSH only within Tailscale

Connection method:

ssh [email protected]

Do not use:

ssh john@public-ip

3. API Keys never enter Git

.env must be in .gitignore.

.env
.env.*

4. Codex runs git status before making changes

Before every major change:

git status
git add .
git commit -m "checkpoint before codex changes"

This way, if Codex breaks something, you can roll back.

XVIII. Quick Command Reference

Remote to Mac mini

ssh [email protected]

tmux

tmux ls
tmux new -s codex
tmux new -As codex
tmux attach -t codex
tmux kill-session -t codex

Codex

codex
codex --version
npm i -g @openai/codex@latest

Lobster / OpenClaw

openclaw status
openclaw status --deep
openclaw doctor
openclaw gateway start
openclaw gateway status --deep
openclaw logs --follow --local-time
openclaw models list
openclaw models status

Power

pmset -g
sudo pmset -a sleep 0 displaysleep 10 disksleep 0 womp 1 tcpkeepalive 1
caffeinate -dimsu

Git

git status
git add .
git commit -m "update"
git push
git pull

XIX. Troubleshooting

1. SSH cannot connect

Check:

ping 100.x.x.x

If ping fails:

1. Is Mac mini powered on?
2. Is Mac mini logged into Tailscale?
3. Is MacBook logged into the same Tailscale account?
4. Is Tailscale backend online?

If ping succeeds but SSH fails:

sudo systemsetup -getremotelogin

Enable:

sudo systemsetup -setremotelogin on

2. Remote desktop cannot connect

Check Mac mini:

System Settings → General → Sharing → Screen Sharing

Confirm it is on.

Connection address:

vnc://100.x.x.x

Do not use public IP.

3. Codex command not found

Check:

which codex
codex --version

Reinstall:

npm i -g @openai/codex@latest

4. Scrolling in tmux is inconvenient

Enter copy mode:

Ctrl + b then [

Exit:

q

It is not recommended to enable mouse mode initially as it may interfere with copying. Configure after you are more familiar. To scroll in tmux, you must use these commands.

5. Lobster gateway is down

Check:

openclaw gateway status --deep
openclaw doctor
openclaw logs --follow --local-time

If restart needed:

openclaw gateway restart

6. Mac mini seems to have lost power or rebooted

First check sleep and system reboot records:

pmset -g log | grep -i "Entering Sleep"
last reboot

Then confirm:

pmset -g

If sleep is not 0, reset sleep prevention.

XX. Final Evolution Roadmap

This system can progress in three phases.

Phase 1: Remote Dedicated Host

Goals:

• Mac Mini always on
• Tailscale connected
• SSH available
• Screen sharing available
• Codex CLI available
• tmux available

At this point, you have your own AI workstation.

Phase 2: Codex as Primary

Goals:

• All projects in ~/dev/github
• Each project has AGENTS.md
• Codex CLI is responsible for editing files
• Codex App handles complex GUI tasks
• GitHub for version management

If you have been deeply using Lobster, keep it for now but stop assigning it complex agent tasks. Gradually migrate processing tasks to Codex.

Phase 3: Lobster Downgraded to Gateway

Goals:

Feishu / WeChat / Scheduled tasks
    ↓
Lobster gateway
    ↓
codex exec / skill CLI
    ↓
Result return

So:

• Lobster receives jobs;
• Codex does the work;
• GitHub keeps the records;
• Mac Mini stays always on.

XXI. Final Form of This System

Ultimately, you don’t want “just a bunch of AI software installed”.

You want your own AI work system:

• You send tasks on MacBook;
• Tasks enter Mac Mini;
• Codex understands the project and executes;
• Lobster handles external message entry;
• Tailscale ensures remote security;
• GitHub saves all results;
• tmux ensures tasks never drop;
• AGENTS.md ensures every project has its own rules.

Once this system is built, the following things become smooth:

1. Write WeChat official account articles, create self-media content
2. Handle work-related tasks
3. Maintain GitHub projects
4. Run Feishu automation bots
5. Do automated daily reports
6. Build image generation pipelines
7. Create your own collaborative growth AI assistant
8. Turn the Mac Mini into a true personal AI server

One sentence:

MacBook is your cockpit;
Mac Mini is your server room;
Codex is your engineer;
Lobster is your message receptionist;
Tailscale is your dedicated network line.

That’s the core logic of this system.

The ultimate goal is to build a personal super AI system that belongs to you.