THE COOKBOOK · FREE

The Agentic Cookbook.

A field guide for building your own agentic cockpit: Claude, Codex/ChatGPT, browser control, MCPs, skills, commands, files, agents, and the operating structure behind a founder-led AI workforce.

This is not another tool list. It is the setup path, prompt, file structure, agent anatomy, command loop, and asset repo for turning AI from random chat into an agentic workforce infrastructure.

00

OVERVIEW

What's inside.

  • Install flow for Claude + Codex/ChatGPT desktop
  • Claude Chrome + Codex Browser setup
  • The init prompt that interviews you before building agents
  • The 6 things every agent needs to function
  • The agent lifecycle: build, assign, schedule, dispatch, visualize
  • Primary layer: Claude Code, Codex desktop, Obsidian, GitHub
  • Secondary layer: APIs, MCPs, CLIs, connectors, apps
  • Third layer: commands, skills, file structure, orchestration rules
  • Agent-owned app stack: what each department agent owns
  • MCP registry + per-department connector map
  • Skills inventory + command recipes
  • Safe agent asset repo: templates, configs, prompts, role docs, setup docs
01

KEYNOTE RECAP

The six-step flow.

  1. 01Download Claude + Codex/GPT desktop.
  2. 02Install Claude Chrome and learn Codex Browser.
  3. 03Paste the init prompt into Claude, Codex, or both.
  4. 04After the AI interview, tell Claude or Codex to build the agent for you.
  5. 05Manage the agents from your phone while you go play golf.
  6. 06Repeat for every agent the interview uncovers.
02

THE MODEL

My actual cockpit.

My laptop stays plugged in at home. My phone becomes the cockpit. I talk to Claude and ChatGPT/Codex apps, and those surfaces connect into my browser, files, apps, GitHub, Obsidian, websites, social accounts, software projects, and client systems.

THIRD LAYER · CONTROL SYSTEM

  • Commands
  • Skills
  • File structure
  • Orchestration rules

SECONDARY LAYER · TOOL PLUMBING

  • APIs
  • MCPs
  • CLIs
  • Connectors
  • Apps

PRIMARY LAYER · TOOLS I TALK TO

  • Claude Code
  • Codex desktop
  • Obsidian
  • GitHub
  • Claude Desktop / Cowork
  • Claude Chrome
  • Codex Browser
  • ChatGPT mobile app
03

THE INIT PROMPT

Start with an orchestrator, not random chat.

Paste this into Claude, Codex, or both. Let the AI interview you first, then tell it to build the agents for you.

INIT PROMPT · SAFE TO COPYSAFE TO COPY
You are my Agent Orchestrator.
Interview me first, one question at a time.
Map my personal brand, business systems, files, apps, and recurring workflows.
Identify the agents I need based on the interview.
For each agent, define its identity, tools, memory, schedule, reporting, and success criteria.
After the interview, build the agent files, prompts, folders, commands, and setup steps for me.
Confirm before changing anything live.

Repeat this process for every agent I need built.

PART I

The surfaces.

The places you actually talk to the agents from. Two ecosystems running in parallel: OpenAI (Codex/ChatGPT) and Anthropic (Claude). Phone supervises both.

01

SURFACE · OPENAI COCKPIT

Codex Desktop / ChatGPT App.

The OpenAI-side cockpit. I use Codex desktop for coding, browser access, implementation passes, visual verification, and fresh-context review. It runs beside Claude, not under it.

BEST AT

  • •Browser control and visual QA
  • •Coding implementation when I want a GPT-side build lane
  • •Fresh-context review after Claude or another agent builds
  • •Running parallel with Claude Code against the same repo
  • •Using the Codex app from desktop while controlling work remotely

INSIDE THE COCKPIT

  • •Codex desktop app
  • •Codex CLI
  • •Codex Browser
  • •ChatGPT mobile app
  • •AGENTS.md / CLAUDE.md compatible project context
  • •Fresh review lane separate from build lane
02

SURFACE · CHAT + COWORK

Claude Desktop.

Home base for the Anthropic side. Regular chat, Cowork, and Claude Code can all run from inside Desktop — and this is where settings, skills, and connectors live.

BEST AT

  • •Daily-driving Claude with full settings + connector control
  • •Cowork sessions — Claude operating alongside you on your machine
  • •Running Claude Code from inside the Desktop app

INSIDE THE COCKPIT

  • •Add connectors (the apps you want Claude to reach)
  • •Add skills
  • •Connect it to your computer
  • •Enable computer use
  • •Enable file access
  • •Enable browser use
03

SURFACE · BROWSER

Claude for Chrome.

Browser-native Claude. Sits in a side panel inside any tab you're already logged into. Great for letting Claude operate the apps you use in the browser.

BEST AT

  • •Operating web apps inside your existing sessions (no API plumbing)
  • •Demoing live workflows on real tools
  • •Driving research + click-paths Claude can see end-to-end

INSIDE THE COCKPIT

  • •Side panel chat inside any tab
  • •Permissioned access to the active tab
  • •Pairs with Desktop connectors and skills
04

SURFACE · BROWSER

Codex Browser.

OpenAI's browser surface. Same idea on the GPT side — Codex driving real web apps, with visual verification and fresh-context review.

BEST AT

  • •Visual QA on real pages
  • •Hand-offs after a Claude build for a GPT-side review
  • •Running parallel lanes against the same outcome

INSIDE THE COCKPIT

  • •Browser session control
  • •Screenshot + DOM awareness
  • •Pairs with Codex CLI and the desktop app
05

SURFACE · TERMINAL

Claude Code.

Claude in the terminal, with full filesystem + repo context. The build lane on the Anthropic side.

BEST AT

  • •Long-running implementation work in a repo
  • •Multi-file edits with plan → diff → apply
  • •Driving commands, skills, and hooks from CLAUDE.md

INSIDE THE COCKPIT

  • •/agents, /skills, /commands, /hooks
  • •CLAUDE.md as operating instructions
  • •Sub-agents and managed dispatch
06

SURFACE · TERMINAL

Codex CLI.

Codex in the terminal. Same build/review surface on the GPT side. Use it as a second lane against the same repo or as the dedicated review lane.

BEST AT

  • •Running a GPT-side build lane parallel to Claude
  • •Fresh-context code review after a Claude pass
  • •Driving AGENTS.md compatible project rules

INSIDE THE COCKPIT

  • •codex exec — run tasks with a story path + tests to satisfy
  • •codex review — review the diff with fresh context
  • •AGENTS.md as operating instructions
07

SURFACE · CLOUD

Claude Console / Managed Agents.

Anthropic-hosted runs. Routines, scheduled tasks, and managed agents that run on Anthropic's servers — not your laptop.

BEST AT

  • •Scheduled work that must run whether your laptop is on or not
  • •Webhook + API-triggered runs
  • •Operationalizing playbooks once they're stable

INSIDE THE COCKPIT

  • •Routines (Pro = 5/day, Max = 15/day)
  • •Managed sub-agents
  • •Per-run connector attachment
08

SURFACE · MOBILE

ChatGPT Mobile App.

The phone is the cockpit. ChatGPT mobile + the Claude mobile app is how I supervise everything while the laptop stays plugged in at home.

BEST AT

  • •Reviewing + approving while away from the desk
  • •Voice-driving the orchestrator
  • •Quick checks on routines, sessions, and dispatches

INSIDE THE COCKPIT

  • •Voice + text chat
  • •Connector context where supported
  • •Pairs with desktop/browser control on your laptop

EXAMPLE ECOSYSTEM

Example Ecosystem: Claude.

This is one ecosystem example, not Bible truth. The point is not worshipping a tool. The point is learning how ecosystems are configured, what each surface owns, and how the cockpit keeps everything pointed at the same outcome.

I run Claude and Codex together. The Claude surfaces above — Desktop / Cowork, Chrome, Code, and Console / Managed Agents — are one half of the cockpit. Codex desktop, CLI, Browser, and ChatGPT mobile are the other half. Pick whichever surface fits the job, not the brand.

PART II

The stack.

Nine categories of plumbing the agents read and write through. Claude and Codex read and write across all of them — through MCPs, browser sessions, files, APIs, and connectors.

THE STACK

What Claude and Codex read and write.

01

Organization.

Full personal audit, full business audit, MD files, GitHub, Obsidian, lockdown files, AGENTS.md, CLAUDE.md.

02

Connection Methods.

MCP, API/SDK, webhooks, OAuth, private tokens / integration keys, browser sessions.

03

Browser Control.

Claude Chrome, Codex Browser, Playwright, Chrome DevTools, auto-browser.

04

Coding Tools.

Claude Code, Codex desktop, Codex CLI, BMAD, Superpowers, code review.

05

Token Reduction + Memory.

Obsidian, GitHub, Mem, Claude mem, context-mode.

06

Design Tools.

Figma, Canva, impeccable, hallmark, design-extract.

07

Prospecting Tools.

Vibe Prospecting, lead research, LinkedIn, email sequence.

08

Deployment Stack.

Vercel, Supabase, Sentry, Redis, Resend, Stripe, GitHub.

09

Connector Assist.

Context7, API skills, MCP builder, connect / connect-apps.

THE PYRAMID

From Start Here to Custom Cockpit.

The build order. Start at the bottom; you graduate up only after the layer below it is real.

  1. APEX

    Your Custom Cockpit

    Custom interface / operating system running locally on your machine.

    09
  2. PEAK

    OpenClaw (Agent Harness)

    Autonomous, multi-model, agent runtime.

    08
  3. ADVANCED

    Claude Code + Codex

    Terminal workflows, browser control, coding agents.

    07
  4. ADVANCED

    Claude Cowork + Codex Browser

    Deploy, dispatch, build agents for you.

    06
  5. CONFIG

    Skills, MCPs, Hooks, Managed Agents

    Primitives, plugins, connectors.

    05
  6. CONFIG

    Claude Desktop + Chrome Extension

    Top starting point, browser access.

    04
  7. FOUNDATION

    Files / GitHub / Obsidian

    Memory, version control, knowledge.

    03
  8. FOUNDATION

    AI Audit — Personal, Business, Ops

    Claude/Codex interviews your life + business.

    02
  9. START HERE

    Start with Claude + Codex

    Foundation. 30 minute setup.

    01

PART III

Agentic Asset Repo.

The giveaway layer. Not secret credentials. Not private client data. The useful assets: role docs, prompts, folder structures, command recipes, MCP maps, skills lists, and setup patterns.

01

ASSET · ROLE DOCS

Agent role docs.

Each agent gets a role doc describing: mission, identity, what it owns, what it does not do, KPIs, skills, MCPs, logs to.

DEPARTMENT MODEL

  • Orchestrator / CEO layer
  • Sales
  • Ads
  • Content
  • Social
  • Analytics
  • Finance
  • Comms
  • Recruiting
  • Logging
  • Engineering
  • Personal Brand
  • OpportunityOS
  • Project agents: Section 125, DSDT, AuditStack, Revive
ROLE DOC TEMPLATE · SAFE TO COPYSAFE TO COPY
# <Department> Agent

## Mission
<One sentence — what this agent exists to do.>

## Identity
- Name:
- Reports to: Orchestrator
- Department:

## Owns
- <Outcome 1>
- <Outcome 2>

## Does Not Do
- <Hard boundary 1>
- <Hard boundary 2>

## KPIs
- <Measurable 1>
- <Measurable 2>

## Skills
- <skill-name>
- <skill-name>

## MCPs / Connectors
- <connector>
- <connector>

## Memory
- Context: memory/context/<dept>.md
- People:  memory/people/<dept>.md
- Project: memory/projects/<project>.md

## Schedule
- Triggers: <schedule | webhook | manual>
- Cadence:  <daily | weekly | on-event>

## Reporting
- Logs to: logs/<dept>/
- Reports to Orchestrator: <when + format>

## Definition of Done
- <Acceptance criteria>
02

ASSET · ORCHESTRATOR

The orchestrator pattern.

The orchestrator is the CEO layer. It does not do department work. It routes, dispatches, quality-gates, synthesizes, and reports back. Every request becomes a mission brief with context, constraints, definition of done, owner, dependencies, and QA checklist.

  • Mission brief
  • Department dispatch
  • Cross-department alignment
  • Progress monitoring
  • QA checklist
  • Delivery + publish-back
03

ASSET · MCP REGISTRY

MCP registry.

LOCAL MCPs

  • NotebookLM
  • Playwright
  • Chrome DevTools
  • Vibe Prospecting
  • Auto-browser
  • Google Surf

CLOUD CONNECTORS

  • Gmail
  • Google Calendar
  • Google Drive
  • Notion
  • Figma
  • Canva
  • Krisp
  • Mem
  • Pipeboard Meta Ads
  • Computer Use

PER-DEPARTMENT MCP MAPPING

AdsPipeboard Meta Ads, Playwright, Chrome DevTools
AnalyticsGoogle Drive, Notion, Krisp
CommsGmail, Google Calendar, Krisp, Notion, Mem
ContentGoogle Drive, Figma, Canva, NotebookLM
FinanceGoogle Drive, Notion
RecruitingGmail, Google Calendar, Notion, Vibe Prospecting
SalesGmail, Google Calendar, Notion, Vibe Prospecting
SocialPlaywright, Canva, Figma
Loggingnone
MCP REGISTRY · SAFE TO COPYSAFE TO COPY
Local MCPs:
  - NotebookLM
  - Playwright
  - Chrome DevTools
  - Vibe Prospecting
  - Auto-browser
  - Google Surf

Cloud Connectors:
  - Gmail
  - Google Calendar
  - Google Drive
  - Notion
  - Figma
  - Canva
  - Krisp
  - Mem
  - Pipeboard Meta Ads
  - Computer Use

Per-Department Mapping:
  Ads        : Pipeboard Meta Ads, Playwright, Chrome DevTools
  Analytics  : Google Drive, Notion, Krisp
  Comms      : Gmail, Google Calendar, Krisp, Notion, Mem
  Content    : Google Drive, Figma, Canva, NotebookLM
  Finance    : Google Drive, Notion
  Recruiting : Gmail, Google Calendar, Notion, Vibe Prospecting
  Sales      : Gmail, Google Calendar, Notion, Vibe Prospecting
  Social     : Playwright, Canva, Figma
  Logging    : none

Bring your own credentials. Never commit tokens.

04

ASSET · SKILLS

Skills inventory.

Marketing + Copy

  • copywriting
  • copy-editing
  • cold-email
  • email-sequence
  • ad-creative
  • social-content
  • internal-comms

SEO + Content

  • seo-audit
  • ai-seo
  • schema-markup
  • programmatic-seo
  • content-strategy
  • content-research-writer
  • competitor-alternatives

CRO + Growth

  • page-cro
  • form-cro
  • signup-flow-cro
  • onboarding-cro
  • popup-cro
  • paywall-upgrade-cro
  • ab-test-setup
  • churn-prevention

Strategy + Research

  • marketing-ideas
  • marketing-psychology
  • launch-strategy
  • pricing-strategy
  • free-tool-strategy
  • paid-ads
  • referral-program
  • analytics-tracking
  • lead-research-assistant
  • competitive-ads-extractor
  • product-marketing-context

Brand + Design

  • impeccable
  • hallmark
  • ui-ux-pro-max
  • brand-guidelines
  • canvas-design
  • theme-factory
  • image-enhancer
  • nano-banana-pro
  • artifacts-builder

Developer + Technical

  • mcp-builder
  • skill-creator
  • webapp-testing
  • systematic-debugging
  • test-driven-development
  • code-reviewer
  • codex:codex-rescue
  • remotion
  • langsmith-fetch
  • n8n-mcp-tools-expert

Productivity

  • connect
  • connect-apps
  • file-organizer
  • invoice-organizer
  • changelog-generator
  • domain-name-brainstormer
  • meeting-insights-analyzer
05

ASSET · COMMANDS

Command recipes.

  • /settings

    Enable remote control and configure the working surface.

  • /ultraplan

    Create an execution protocol before building.

  • /goal

    Point the agent at the protocol and mission.

  • /agents

    Build agents around the goal.

  • /ultrareview

    Review output against the plan.

  • codex exec "<task + story path + test to satisfy>"

    Run Codex as a build lane.

  • codex review (or a fresh Codex pass)

    Run GPT-side review separate from build context.

COMMAND RECIPES · SAFE TO COPYSAFE TO COPY
/settings
  → Enable remote control and configure the working surface.

/ultraplan
  → Create an execution protocol before building.

/goal
  → Point the agent at the protocol and mission.

/agents
  → Build agents around the goal.

/ultrareview
  → Review output against the plan.

codex exec "<task + story path + test to satisfy>"
  → Run Codex as a build lane.

codex review (or a fresh Codex pass)
  → Run GPT-side review separate from build context.
06

ASSET · WORKSPACE ARCHITECTURE

Three-tier lockdown.

The canonical workspace pattern: Tier 1 hot cache, Tier 2 deep memory, Tier 3 working artifact — plus the full .claude/ scaffold.

TIER 1

HOT CACHE

CLAUDE.md auto-loaded each session. Kept to 50–80 lines. Acts as the hub/index pointing down into Tier 2. Holds the .claude/ config folder: settings, rules, commands, skills, agents, hooks.

TIER 2

DEEP MEMORY

memory/ lazy-loaded only when Tier 1 references it. Never committed to git. Subfolders: people/, projects/, context/ — with credentials.md (chmod 600) for long-lived, revocable, scoped creds only.

TIER 3

WORKING ARTIFACT

<client>-site-bundle/ — a flat .md / .json mirror of the live thing. Canonical source of truth. Bundle wins over memory; memory describes, bundle decides.

WORKSPACE TREE · SAFE TO COPYSAFE TO COPY
WORKSPACE ROOT
│
├── CLAUDE.md ─────────────────────────  ◄── TIER 1 — HOT CACHE
│     • Lives at workspace root
│     • Auto-loaded at session start
│     • Kept SHORT: 50–80 lines max — it's an index, not a manual
│     • Acts as the hub — points down into Tier 2 when needed
│     • Defines project overview, tech stack, commands
│     • Contains coding conventions & architecture
│     • Supports CLAUDE.local.md overrides
│
├── Claude.local.md
│     • Local override of CLAUDE.md (gitignored, per-developer)
│
├── .mcp.json
│     • Stores MCP integration configs
│     • Connects to GitHub, JIRA, Slack, DBs
│     • Shared across team via git
│
├── .claude/   ◄── CLAUDE-FACING CONFIG (sits inside Tier 1)
│     │
│     ├── settings.json
│     │     • Controls permissions & tool access
│     │     • Defines model selection and hooks
│     │     • Supports settings.local.json overrides
│     │
│     ├── settings.local.json
│     │     • Local override of settings.json (gitignored)
│     │
│     ├── rules/
│     │     • Modular .md files by topic
│     │     • Covers style, testing, API design
│     │     • Can target specific files/paths
│     │     ├── code-style.md
│     │     ├── testing.md
│     │     └── api-conventions.md
│     │
│     ├── commands/
│     │     • Custom slash commands (/project:<name>)
│     │     • Used for repeatable workflows
│     │     • Supports shell execution
│     │     ├── review.md
│     │     └── fix-issue.md
│     │
│     ├── skills/
│     │     • Auto-triggered based on task context
│     │     • Loads only when needed
│     │     • Keeps context lightweight
│     │     └── deploy/
│     │           ├── skill.md
│     │           └── deploy-config.md
│     │
│     ├── agents/
│     │     • Specialized sub-agents with roles
│     │     • Isolated context windows
│     │     • Custom tools and model preferences
│     │     ├── codeReviewer.md
│     │     └── security-auditor.md
│     │
│     └── hooks/
│           • Event-driven scripts (pre/post tool use)
│           • Automates validation, linting, formatting
│           • Blocks unsafe operations
│           └── validate-bash.sh
│
├── memory/ ─────────────────────────  ◄── TIER 2 — DEEP MEMORY
│     • Lazy-loaded — only pulled when CLAUDE.md references it
│     • NEVER commit to git (sensitive + high churn)
│     • Use predictable slugs so the hub can point cleanly
│     ├── people/        (one .md per person)
│     ├── projects/      (one .md per project)
│     └── context/       (general context files)
│           └── credentials.md   (chmod 600)
│                 • Long-lived, revocable, scoped creds ONLY
│                   (e.g. WordPress Application Passwords)
│                 • Document the revocation path inline
│                 • REFUSE to store: real account logins,
│                   private keys, payment info
│
└── <client>-site-bundle/ ──────────  ◄── TIER 3 — WORKING ARTIFACT
      • Flat file mirror of the live site
      • Canonical source of truth — bundle wins over memory
      • Everything stored as .md / .json (no proprietary formats)

BEST-PRACTICE GUARDRAILS

  • •Declare a canonical source — the bundle is it.
  • •Keep CLAUDE.md under 80 lines — index, not manual.
  • •Use predictable slugs so Tier 1 points cleanly at Tier 2.
  • •Lazy-load detail — don't preload memory/.
  • •Bundle decides; memory describes.
  • •Never commit memory/ to git.
  • •Credentials: long-lived, revocable, scoped only — nothing else lives in the workspace.
07

ASSET · EXAMPLE STACK

OpportunityOS — agent-owned product.

An example of how a product can be designed around agent ownership. One owner per task. No orphan logic.

Ozzy

Orchestrator

Danny

Intent data

Emily

Email

Lindie

LinkedIn

Addie

Ads

Chad

Booking chatbot

FINAL CTA

Build your first agent tonight.

Start with the init prompt. Let Claude, Codex, or both interview you. Then make the AI build the agent files, prompts, folders, commands, and setup steps for you. Repeat until every department in your business has an owner.

Want help building it? Explore Future Proof Foundry.