# Cooking with Codex — Charlie Guo & Gabriel Chua, OpenAI

## Executive summary

This workshop provides a comprehensive overview of Codex, an advanced AI agent, demonstrating its capability to automate complex, multi-stage development and operational workflows. The core methodology involves giving Codex detailed context (via plugins, appshots, and memory), allowing it to execute tasks through various interfaces (Computer Use, Chrome Extension), and managing long-running processes using advanced primitives like Goals, Subagents, and Thread Handoff. The ultimate goal is to move beyond single-turn prompts toward building fully automated 'software factories' that can manage entire development lifecycles.

## Key takeaways

- Context is the most critical ingredient for Codex.: Codex requires rich context, which can be supplied through external sources (Plugins for Slack, Gmail, etc.), visual inputs (Appshots), and persistent memory (Chronicle/Personalization).
- Advanced workflow management uses Goals, Subagents, and Thread Handoff.: For complex, long-running tasks, use the `Goal` skill to define verifiable completion criteria. Subagents allow for specialized, parallel workstreams, while Thread Handoff enables visible communication between different parts of the agent's work.
- The App Server enables embedding Codex into custom products.: The App Server protocol is the core mechanism for integrating Codex's power (including context compaction and agent harness features) into proprietary or third-party applications, allowing users to leverage their existing ChatGPT token budget.
- Automations create repeatable, scheduled processes.: Automations (Heartbeat and Scheduled) allow agents to monitor systems (e.g., checking for deployment readiness, summarizing feedback) and trigger subsequent tasks or worktrees without constant human supervision.

## Technical details

- Agent Control Modes: Codex offers multiple ways to interact with applications: `Computer Use` (general OS control for legacy or non-API applications), the `Chrome extension` (best for handoff/authorization in signed-in browser sessions), and the `Inapp browser` (for deep local web application testing).
- Workflow Primitives: The `agents SDK` provides tools like `Goal` (defining verifiable success criteria), `Subagents` (delegating specific tasks, e.g., a code reviewer), and `Thread-to-thread handoff` (managing visible, sequential communication between different agent processes).
- System Architecture: The `App Server` is the core, open-source protocol that unifies Codex's capabilities (compaction, plugins, agent harness) for embedding into external platforms, allowing for enterprise-grade integration.
- Deterministic Checks and Guardrails: Hooks allow developers to introduce deterministic behavior at specific checkpoints in the development lifecycle (e.g., running an linter or checking for sensitive API keys) to ensure quality and security.

## Practical implications

- Automating complex, multi-day development tasks (e.g., building a full Q&A site or reimplementing a package) by defining clear goals and milestones.
- Reducing manual overhead in data collection by using agents to interact with non-API enterprise dashboards and extract structured data (CSV/JSON).
- Building internal, customized SaaS tools (like form builders) using existing open-source repositories without relying on paid services.
- Establishing a 'software factory' concept where agents manage the entire development pipeline, from initial concept to final review and deployment.

## Topics

AI Agents, LLM Automation, Software Development Lifecycle (SDLC), Agent Orchestration, OpenAI/Codex, App Server Integration, agents SDK, App Server Protocol

Source: https://www.youtube.com/watch?v=FwiS44-xyYw