Codex

AI memory vault structure

• The personal-monorepo-template gives an AI assistant (Codex) a durable 'vault' repo with projects/ (active work), experiments/ (short spikes), people/ (collaborators/agents), .codex/skills/ (repo-local skills), templates/, and tests/ — a place to check context before acting and write approved context after. (from codex personal monorepo vault template)
• Setup workflow: clone the template to ~/vault (rm -rf .git; git init to detach from origin), create a Codex project rooted at ~/vault, then start a new thread and say "$onboard me" to trigger onboarding. (from codex personal monorepo vault template)

AI agent onboarding automation

• Onboarding scans connected Slack, email, calendar, docs, project trackers, and GitHub to proactively propose people/*.md notes, project packets, and AGENTS.md updates; it also offers default monitoring automations (daily update monitor, people monitor, project monitors) defaulting to 9:00 AM and 4:00 PM check-ins in the user's timezone, plus a 'write-like-me-bootstrap' skill that derives a writing-style skill from sent Slack and email messages. (from codex personal monorepo vault template)

agent permission gating

• The assistant design enforces an explicit approval gate: it must ask before sending messages, changing meetings, editing shared docs, creating automations, creating/pinning/renaming/looping threads, installing plugins, or writing to shared memory — keeping humans in the loop for any state-changing action. (from codex personal monorepo vault template)

agentic coding prompt template

• Full prompt template for Codex + GPT-5.6 Sol: give the model one complete spec/task and instruct it to 'take the whole plan to done' until architecture, implementation, tests, review, and final result all clear the bar—rather than stopping at partial progress. (from codex parallel subagent prompt template)

parallel subagent decomposition

• The prompt instructs the model to break the end-to-end goal into independent parts and spawn as many parallel agents as needed, giving each subagent its own deliverable, verification method, and explicit done criteria—leveraging Codex's parallel subagent capability. (from codex parallel subagent prompt template)

agent operator orchestration

• The model is directed to run itself like an operator: schedule agents in parallel, track their progress, synthesize returned work, resolve conflicts between subagent outputs, keep implementing, verify live after every important step, review when it matters, commit when ready, and close with a final summary. (from codex parallel subagent prompt template)

computer-use verification

• Verification in this workflow is required to cover the real end-to-end path, including browser and computer use (clicks, keyboard actions)—not just code-level checks—reflecting Codex's newer computer-use strength. (from codex parallel subagent prompt template)

agent stop conditions

• The prompt sets explicit stop conditions: the agent should not halt at partial progress unless blocked by missing credentials, destructive ambiguity, or conflicting requirements—otherwise it must keep pushing the task to completion. (from codex parallel subagent prompt template)

Installation & Auth

• Install via: /plugin marketplace add openai/codex-plugin-cc then /plugin install codex@openai-codex. Requires Node.js 18.18+, and either a ChatGPT subscription (incl. Free tier) or OpenAI API key. Usage counts against Codex limits. (from codex plugin claude code)

Code Review Commands

• /codex:review runs a read-only Codex review on uncommitted changes or a branch (--base main). /codex:adversarial-review pressure-tests design choices, tradeoffs, hidden assumptions, and failure modes (auth, race conditions, rollback). Both support --background. (from codex plugin claude code)

Task Delegation

• /codex:rescue delegates tasks (bug investigation, fixes, continuing previous runs) to Codex as a subagent. Supports --model, --effort, --resume, --fresh, and --background. Shorthand spark maps to gpt-5.3-codex-spark. (from codex plugin claude code)

Cross-Agent Session Handoff

• /codex:transfer exports the current Claude Code session context into a persistent Codex thread and prints a codex resume <session-id> command, enabling seamless mid-conversation handoff from Claude to Codex App or TUI. (from codex plugin claude code)

Automated Review Gate

• The optional review gate (/codex:setup --enable-review-gate) uses a Stop hook to auto-trigger a Codex review after each Claude response; if issues are found, the stop is blocked. Warning: can create long Claude/Codex loops draining usage limits rapidly. (from codex plugin claude code)

Configuration

• Model and effort defaults can be overridden per-project via .codex/config.toml at repo root (e.g., model = "gpt-5.4-mini", model_reasoning_effort = "high"). Project-level config only loads when the project is trusted. (from codex plugin claude code)

Architecture & Auth Model

• The plugin uses the local Codex CLI and app server — same install, auth state, repo checkout, and config. No separate Codex account needed if already signed in; codex login supports both ChatGPT account and API key auth. (from codex plugin claude code)

Agent Tool Routing

• Hybrid Claude + Codex agent workflow reduced wasted end-to-end agent-driven PRs from ~50% to 0%. Claude handles computer use and UI/UX verification; Codex handles execution on well-spec'd work. Complementary tool routing is the key mechanism. (from theo claude codex workflow)

CLAUDE.md as Agent Router

• CLAUDE.md configuration is the control plane for multi-tool agent workflows. Theo's CLAUDE.md specifies which tasks route to Codex vs Claude, enabling consistent agent behavior without manual intervention per task. (from theo claude codex workflow)

Claude vs Codex Capability Split

• Claude is described as WAY better than Codex at computer use, UI/UX verification, and general-purpose agent execution — Codex excels specifically on well-specified, deterministic work. This capability split drives the routing decision. (from theo claude codex workflow)

Hierarchical Agent Cost Optimization

• Architecture split: Fable plans and architects the hardest issues on 'high' compute, while Codex subagents execute on 'xhigh' via the CC Codex plugin. This fan-out pattern saves usage by reserving expensive reasoning only for architectural decisions. (from vinvan fable software factory)

Prompt Phrase Patterns

• 'Framing context' is a high-signal phrase for Codex prompts: adding it to requests for docs, handoffs, or summaries causes Codex to include relevant background, history, and intent automatically—without requiring the user to specify what that context is. (from codex framing context prompt pattern)

Codex Workflow Templates

• Three proven Codex prompt templates using 'framing context': (1) 'create a self-contained doc for [issue] with framing context', (2) 'write a handoff to [agent] with all relevant framing context', (3) 'refresh me on recent work with all important framing context in plain language'. (from codex framing context prompt pattern)

Autonomous QA loop

• A single Codex prompt can chain three autonomous phases: (1) enumerate all features from code → user stories in a canonical spreadsheet, (2) test every user story and document errors, (3) fix all UX/logic errors and retest. Hundreds of user stories processed without manual intervention. (from codex loop automation user stories)

Conditional loop prompting

• The loop prompt pattern uses conditional sequencing ('when done switch loop to…') to keep Codex in an agentic state across phases, effectively turning a single instruction into a multi-stage autonomous agent without custom orchestration code. (from codex loop automation user stories)

Code-to-spec inference

• Codex can infer expected behavior from existing code to produce user stories—no separate spec document required. This makes reverse-engineering QA coverage from legacy or vibe-coded apps a tractable one-command task. (from codex loop automation user stories)

Agent Engineering Workflow

• Superpowers (227k stars) gives Codex a senior-engineer loop: decompose requirements → write plan → test-driven development → spawn a sub-agent to review its own output. Widely considered the strongest single Skill for autonomous coding quality. (from codex top 6 skills 2025)

Codex as Cross-Functional Platform

• OpenAI's official Codex plugin ships 110 pre-built Skills and integrates 62 business apps (Snowflake, Salesforce, etc.), enabling non-developer workflows like sales, data analysis, and slide generation. Non-developers now represent ~20% of Codex users and the share is rising. (from codex top 6 skills 2025)

Agent Memory Architecture

• claude-mem (82k stars) adds persistent long-term memory to Codex: key conversation data is compressed and archived automatically, then injected into new sessions. Memory is shared across multiple agents, eliminating repeated project-context onboarding. (from codex top 6 skills 2025)

• Shared memory pattern: anchor persistent threads in an Obsidian vault (vault/TODO.md, people/, projects/, agent/, notes/). AGENTS.md defines routing rules—prefer canonical notes, route context explicitly, avoid churn if nothing meaningful changed. Vault holds rolling context; repo holds code. (from codex work os patterns)

Multi-Platform Data Access for Agents

• Agent-Reach (27.7k stars) extends Codex beyond web search to 17 platforms including Twitter, Reddit, YouTube, Xiaohongshu, Bilibili, and WeChat public accounts via a single CLI command, enabling real-time social signal ingestion. (from codex top 6 skills 2025)

Legacy Codebase Comprehension

• GitNexus (42k stars) builds a dependency/module/naming graph from large legacy codebases, giving Codex structural context for refactoring and bug archaeology. Addresses the core weakness of LLMs on multi-hundred-thousand-line repos. (from codex top 6 skills 2025)

Demo-to-skill automation

• Codex's Record & Replay captures a user-demonstrated workflow (e.g., expense filing, time-off requests) and converts it into an inspectable, editable skill—enabling one-time demos to become reusable automation without manual scripting. (from codex record replay skill)

User control in agent automation

• Skills created via Record & Replay are inspectable and editable, meaning users retain full visibility and control over what was recorded—addressing the black-box concern common to automation tools. (from codex record replay skill)

Convergent agent skill patterns

• The pattern—show once, reuse as a skill—parallels Hermes Agent's self-improving skill architecture and Fable 5's convert-usage-patterns-to-skills approach, suggesting skill extraction from demonstration is converging as a standard agent UX primitive. (from codex record replay skill)

AI Design Skills

• Impeccable (impeccable.style) is a single design skill with 23 commands and curated anti-patterns for frontend design. It works across Cursor, Claude Code, GitHub Copilot, Gemini CLI, and Codex CLI — rated more practically useful than popular alternatives like uiuxpromax. (from codex design skills impeccable taste)

Image-to-Code Pipeline

• The Taste skill workflow uses two components: imagegen-frontend-web (calls GPT Image2 to generate design reference images) + image-to-code (1:1 converts images to web pages). Install both from the Taste skill GitHub repo; the pairing bridges design ideation to production code. (from codex design skills impeccable taste)

Codex Frontend Engineering

• Codex's built-in Frontend App Builder skill (searchable in Skill market) follows the same generate-then-convert flow as Taste but enforces stricter fidelity: colors cannot be loosely interpreted and icon styles must be individually aligned. The Build Web Apps plugin bundles this skill with shadcn/ui components and browser acceptance testing. (from codex design skills impeccable taste)

Codex Skill Architecture

• Codex skills vs. plugins distinction: a Skill is a single reusable task instruction; a Plugin is a bundled set of Skills plus optional tool integrations. Installing a Plugin batch-installs its Skills, which also appear in the Skills management panel. Third-party skills install via GitHub URL, defaulting to global scope; add 'to current working directory' for project-scoped install. (from codex design skills impeccable taste)

Custom Skill Creation

• The recommended way to create custom Codex skills is to extract them from real validated workflows rather than generating from scratch — they inherit tested heuristics and corrected failure modes. The built-in skill-creator skill structures the process; alternatively, prompt Codex to distill a project's reusable patterns directly from conversation history. (from codex design skills impeccable taste)

Codex self-management

• Codex can now self-manage its own threads: creating, searching, organizing, pinning important ones, and spinning up worktrees for parallel tasks — removing the human-in-the-loop bottleneck for task orchestration within Codex itself. (from codex self managing agent)

Agent-as-work-OS

• The pattern emerging from Codex self-management: delegating meta-level work (tracking, organizing, routing tasks) to the agent itself, not just object-level coding. This shifts Codex from tool to personal work OS. (from codex self managing agent)

Codex thread orchestration

• Chief of Staff pattern for Codex: one persistent thread holds all cross-context knowledge (Slack, etc.) and spawns child threads per project. The CoS thread runs heartbeat check-ins on project threads and routes relevant Slack updates to them, so priority naturally surfaces upward without manual triage. (from codex chief of staff thread architecture)

Codex native capabilities

• Codex now has native thread management primitives: create threads, search them, organize and pin important ones, and spin up worktrees for parallel tasks. This enables self-organizing agent topologies without external scaffolding. (from codex chief of staff thread architecture)

Agentic Self-Management

• Codex can now create, search, organize, and pin its own threads — offloading thread management from the user to the agent itself. This closes a key friction point in multi-session workflows where context sprawl previously required manual curation. (from codex self managing threads)

Parallel Task Execution

• Codex can spin up git worktrees autonomously for parallel tasks, enabling concurrent workstreams without manual branch or worktree setup. This mirrors the Claude Code pattern of one agent per worktree but executed self-directed rather than user-initiated. (from codex self managing threads)

Real-time meeting transcription in Codex

• Codex Meeting Recorder skill uses GPT Realtime Whisper to transcribe meetings live, display transcripts in the preview pane, and answer questions about the transcript mid-meeting — full transcript plus formatted summary generated on completion. (from codex realtime meeting transcription)

Cost tradeoff: real-time vs. batch transcription

• GPT Realtime Whisper endpoint costs $0.017/min (~$0.51 for a 30-min meeting), meaningfully more expensive than post-meeting batch transcription. This is the core cost tradeoff for choosing real-time vs. deferred transcription. (from codex realtime meeting transcription)

Local speech streaming as cloud cost escape hatch

• Nemotron Speech Streaming is cited as a candidate local real-time transcription alternative to GPT Realtime Whisper, potentially eliminating per-minute cloud costs for Codex meeting transcription. (from codex realtime meeting transcription)

Evidence-Ordered Workflow Discovery

• The Codex self-packaging prompt uses a strict evidence hierarchy: sessions → Memories/rollout summaries → Chronicle (discovery only, confirm in source system) → existing skills/agents. Chronicle is explicitly limited to discovery to avoid acting on stale or unverified data. (from codex self packaging prompt)

Workflow Packaging Qualification Gates

• The prompt enforces a 4-gate filter before acting: occurred ≥2 times or clearly likely to recur; stable inputs + repeatable procedure + clear stopping condition; materially improves speed/quality/consistency; not already covered. All four must hold to proceed. (from codex self packaging prompt)

Minimal Viable Automation Selection

• Four output forms are ranked by scope: Skill (reusable playbook), Custom subagent (bounded specialist), Automation (scheduled monitor/report), or Skip. The prompt mandates choosing the smallest appropriate form, biasing against over-engineering. (from codex self packaging prompt)

Post-Creation Audit Pattern

• The prompt closes with a mandatory three-part audit: what was created/extended, what was deliberately skipped, and what needs more evidence before packaging. This structured retrospective prevents accumulation of speculative or low-confidence assets. (from codex self packaging prompt)

Async visibility over sync meetings

• Replace status-update 1:1s with public Slack/Linear channels and agents like Codex connected to those channels. Caveat: don't react to every update or the team will move to a private channel without you. (from one on ones management framework)

Human-AI Collaboration Structure

• The 'human sandwich' pattern: humans bookend every complex AI task—specifying the goal, reviewing output, and deciding next steps. This is why Codex, Claude Code, and Cowork are operating systems for collaboration, not pure delegation. Removing the human from complex tasks degrades output quality consistently. (from after automation ai expert demand)

Durable Thread Patterns

• Durable pinned threads act as persistent workspaces with Cmd+1–9 shortcuts. Recommended archetypes: Chief of Staff thread, release thread, documentation review thread, external monitoring thread. Context accumulates across sessions rather than resetting. (from codex work os patterns)

Agent Task Control

• Steering vs. queuing is a key control distinction: steering interrupts an in-flight task with new direction before the current step finishes; queuing adds the next task to the line without interrupting. Both keep users close to the work as it unfolds. (from codex work os patterns)

Autonomous Thread Scheduling

• Thread automations are heartbeat-style recurring wake-ups that return to the same thread on a schedule. Example: Chief of Staff thread running every 30 min to check Slack/Gmail, research answers, and draft replies—but not send them. The expensive context-gathering is done before the user returns. (from codex work os patterns)

Agent Goal Design

• Goals require explicit verifiers to be meaningful. Weak: 'Implement the plan.' Strong: finish condition tied to passing unit tests, a benchmark, bug reproduction, or end-to-end workflow. Without a verifier, a goal is just a wish. (from codex work os patterns)

Tool Tier Routing

• Tool layers extend Codex reach in distinct tiers: $browser for in-app side-panel browser review; @chrome for signed-in Chrome workflows needing user session state; @computer for tasks that only exist through desktop GUI. Choosing the wrong tier breaks signed-in workflows. (from codex work os patterns)

Voice as Input Medium

• Voice input captures rough thought before compression into polished prose. Raw meeting transcripts or dictated planning notes outperform short summaries as source material because they preserve uncertainty, emphasis, and unfinished lines of thought. (from codex work os patterns)

Reusable Workflow Packaging

• Skills package proven workflows so Codex can rerun them without relearning from scratch. Static index.html artifacts can become durable interactive outputs with no server; thread automations can refresh them on a schedule so something new is ready when the user returns. (from codex work os patterns)

Codex Remote Dev Network

• Codex remote setup: on your primary machine enable Settings > Connections > 'Control this Mac'; on every other device enable 'Control other devices'. Combine with Tailscale on all devices to create a private mesh network. Agents like OpenClaw or Hermes can then traverse machines and make changes remotely. (from codex remote multi device network)

Single-Node Dev Architecture

• The architecture designates one always-on desktop (Mac Mini or Mac Studio recommended) as the sole code-writing node; all other devices are stateless control surfaces. This centralizes the codebase in one place regardless of which device or location the operator is working from. (from codex remote multi device network)

Tailscale as Agent Network Dependency

• Tailscale is the enabling layer for Codex's multi-device agent routing — without it, remote agents cannot jump between machines. This makes Tailscale a hard dependency for multi-machine Codex setups, not an optional enhancement. (from codex remote multi device network)

Durable thread management

• Pinned megathreads (one per workstream: Chief of Staff, Agents SDK, Twitter monitor, etc.) accumulate history and preferences across months. Access via Command-1 through Command-9. Tradeoff: long threads likely fall out of cache, incurring higher cost than fresh short threads—continuity is worth it for important workstreams. (from codex maxxing jason liu)

Automated recurring loops

• Heartbeats are thread-local automations that schedule recurring checks without human presence. Example: Chief of Staff thread runs every 30 min to scan Slack and Gmail, drafts replies but never sends them. A single loop can cross tool boundaries—Slack feedback → Remotion render → @computer for file upload—without manual intervention between steps. (from codex maxxing jason liu)

Structured agent memory

• Agent memory should live as files in an Obsidian vault (kept as a GitHub repo), not just as conversation history. AGENTS.md at vault root instructs agents to update people/, projects/, and notes/ pages as they learn. GitHub diffs become a review surface showing what the agent judged important enough to persist—preventing silent accumulation of 'vibes' in chat history. (from codex maxxing jason liu)

Voice as high-bandwidth context

• Voice input's value is not speed but fidelity: the agent receives the unedited, messy version of your thinking. Combining Wispr Flow (system-wide dictation) with Codex's built-in voice, and piping call transcripts via Granola, gives the model richer context than polished typed prompts ever would. (from codex maxxing jason liu)

Asynchronous agent supervision

• Steering lets you inject the next instruction after each tool call while the agent is still working, building a queue of intent before walking away. Heartbeats then monitor long-running outcomes (PR state, Slack replies) after you leave—converting 'one prompt, one answer' into a persistent operating loop. (from codex maxxing jason liu)

Artifact inspection surface

• The side panel is where Codex becomes a work surface rather than a chat app: it renders Markdown (commentable), spreadsheets (formula-aware, cell-editable), CSVs, PDFs (LaTeX-ready), and slides. The in-app $browser lets the agent see and control the same web surface you are annotating—closing the inspect-edit loop without switching tools. (from codex maxxing jason liu)

Goal specification with oracles

• Goals need a verifiable oracle, not just an intent. Weak: 'implement the plan in this Markdown.' Strong: 'migrate Python Rich to Rust and pass all original unit tests.' The test suite acts as a continuous success criterion the agent can push against autonomously—ambition without verification is just a wish. (from codex maxxing jason liu)

Lightweight artifact format

• index.html is preferred over Markdown as Codex output format: it is a self-contained application, requires no server, opens instantly in the side panel, and can be updated by Heartbeats so a fresh artifact is waiting on thread return. Use Vite only when heavier tooling is unavoidable—it requires a persistent server. (from codex maxxing jason liu)

Goal evaluation architecture

• Claude Code /goal and Codex /goal separate doing from judging: a working agent loops across turns while a small fast model (Haiku by default) evaluates whether the stated condition is met from conversation evidence alone—it cannot run commands or read files independently. (from goal command agentic coding pm)

Goal specification structure

• A strong /goal specifies: target state referencing a spec file, observable acceptance criteria, exact validation commands (e.g. 'npm test -- onboarding exits 0'), file-path boundaries, and a turn/time stop condition with a status report. The evaluator judges from transcript proof, not vibes. (from goal command agentic coding pm)

When /goal fits vs. when it doesn't

• /goal is best suited to concrete, cheaply-validatable work: import migrations, failing-test backlog clearance, file-splitting to size budgets, brute-force edge-case testing. Exploration goals should produce bounded artifacts (e.g. docs/search-speed-options.md) not silently become production loops. (from goal command agentic coding pm)

Goal prompt structure

• The /goal command works across Codex, Claude Code, and Hermes. The common failure mode is writing vague goals like 'make no mistakes'—the fix is a structured template with eight named sections that force clarity before execution. (from goal command structure codex claude)

Uncertainty handling in agent prompts

• STOP RULES section is the highest-leverage addition: halt on high-impact ambiguity or risk; surface uncertainties with ranked highest-confidence proposals before acting (not open-ended questions); do not expand scope after goal is satisfied. This directly targets scope creep and hallucinated architecture. (from goal command structure codex claude)

Verifiable agent completion

• VERIFY section must include: tests/build/lint/typecheck/manual validation; explicit statement of what could not be verified and why; and a rollback/containment plan for destructive or high-risk changes—making incompleteness visible rather than hidden. (from goal command structure codex claude)

Multi-device Codex topology

• A Mac mini (always-on, reliable Wi-Fi) as the 'home' node + MacBook as 'satellite' + mutual SSH between them lets Codex threads start on any device and resume on any other, including phone. Eliminates the single-machine constraint of local dev agents. (from codex satellite home device topology)

Always-on agent persistence

• 'Heartbeat threads'—persistent Codex sessions running 24/7 on the always-on Mac mini—are a concrete pattern for maintaining continuous agent context independent of whether any laptop is open. (from codex satellite home device topology)

Device-agnostic AI agent infrastructure

• The author frames this makeshift setup as a preview of near-future work: AI coding agents become ambient infrastructure accessible from any device rather than tools tied to whichever machine is open. The friction today is SSH/Wi-Fi reliability, not the model. (from codex satellite home device topology)

Codex Plugin Ecosystem

• Chrome Browser and Hyperframe are both Codex plugins, enabling direct integration of browser control and frame/layout tooling into Codex-based AI creative workflows without custom integration work. (from codex plugins chrome hyperframe)

Codex Beyond Code

• The framing of 'AI creative process' applied to Codex plugins (Chrome Browser, Hyperframe) signals Codex is being used beyond code generation—into design, layout, and creative production pipelines. (from codex plugins chrome hyperframe)

Model routing layer as durable competitive moat

• Sierra routes tasks to different models (Claude Code, Codex) via an owned orchestration layer. Owning the routing layer—not the underlying model—is the durable advantage: best model for planning vs. coding vs. prose, with failover and cost management. (from ai pilling our company in 1968 a seminal study found something that would shap)

SaaS displacement via vibe-coding

• Codex can replace a $30/mo SaaS (Superhuman) with a fully customisable agent-native email client running on Gmail CLI, replicating UX patterns while removing vendor lock-in. (from bentossell diy email client codex)

AI-built SaaS alternatives

• The pattern: identify a subscription SaaS with well-understood UX conventions, replicate those conventions via an agent-built CLI tool, and replace recurring cost with one-time build effort. Superhuman → Gmail CLI is the worked example. (from bentossell diy email client codex)