I refreshed the current AI Engineer World's Fair sources on June 30, 2026: AI Engineer World's Fair schedule v4844, 568 sessions, 549 speakers, and official tracks covering Computer Use, Voice & Realtime AI, Context Engineering, Local AI, Software Factories, Claws & Personal Agents, Vision & OCR, and Harness Engineering. The session list includes Cooking with Codex with Charlie Guo and Gabriel Chua. That makes the right question very concrete: what should a builder actually cook?
gpt-realtime-2;
the raster image workflow belongs to image generation, not Realtime.
A Codex demo is done only when the goal, source receipts, chosen tool plane, visible state change, verification command, and reusable skill/reference packet all exist in the same artifact chain.
Start from the method, not the plugin list
I am using "the Matias Duarte method" here as a design lens, not as a sourced quote: begin with the human state transition. What does the person know, what can they safely do next, what feedback appears, and what remains reversible? If the demo cannot answer those questions in the first minute, the model choice is premature.
The "Charlie Guo method" is the Codex cooking lens I would use from the World's Fair prompt: do not ask one giant agent to be impressive. Give Codex a clear goal, a current appshot or browser surface, the narrowest useful tool plane, and a proof step it must run before the story counts. The public schedule confirms the Codex cooking session; this note turns that pressure into the actual operating loop.
The review board I would use
This is an inferred operator review board, not a set of quotations or endorsements. I would use these public-source lenses to make a Codex demo harder to fool and easier to reuse.
Make the agent do the thing.
Source lens: the World's Fair schedule pairs Cooking with Codex with Charlie Guo and Gabriel Chua, and also lists Charlie's Voice Agents Can Just Do Things. The review question is whether the agent performed a visible action, picked the right surface, and left proof.
AIE sessions JSONStress-test the idea before code.
Source lens: YC describes GStack as skills for office hours, design, code review, QA, and browser testing across Claude Code, Codex, or Cursor. The demo should start with adversarial office hours, then move through design, code review, and QA in one loop.
YC GStack walkthroughFind the users who love it.
Source lens: the Startup Playbook keeps product love, clear users, focus, and execution quality ahead of demo theatrics. The Codex cooking pass should identify a narrow power user and prove the workflow saves that person real time.
Startup PlaybookRaise capability and safeguards together.
Source lens: Anthropic's Responsible Scaling Policy treats more capable models as requiring stronger risk reports, security controls, and deployment safeguards. A Codex demo that gains tool authority should add evals, boundaries, rollback, and misuse checks at the same time.
Responsible Scaling PolicyComputer Use vs Chrome vs Browser
The most useful Codex decision is often not "which model?" It is "which surface should Codex operate through?" The wrong surface creates fake difficulty. The right one makes the demo shorter and more inspectable.
gpt-realtime-2 for low-latency voice agents; use gpt-image-2 and vision for visual artifacts.
Voice session trace, interruption behavior, generated image asset, or vision analysis with source image.
The top five frontier cooks from 2026 Q2+
The interesting pattern from the current docs and conference data is not one tool. It is the convergence of execution surfaces, packaging, live UI proof, and stateful backends. These are the five I would copy first.
- Codex as a multi-surface execution plane. The desktop app, cloud tasks, appshots, subagents, worktrees, Browser, and connected hosts let one goal move between local code, rendered UI, and remote execution without collapsing into chat history.
- The Browser, Chrome, and Computer Use split. Browser is for public/local web surfaces, Chrome is for signed-in web state, and Computer Use is for desktop UI. This distinction is now a core product skill.
-
Agent Skills as the reusable packaging layer.
The agentskills.io layout gives every serious workflow a
SKILL.md, optionalreferences/,scripts/, andassets/. That is how a one-off demo becomes a sibling-project capability. - Reactive agent backends. Convex's Agent component describes message history, vector search, long-running workflows, and real-time database reactivity in one app surface. That is the shape of a useful progress dashboard, not just a chat widget.
- Separate realtime voice from visual generation. Realtime is the live voice/tool loop. Image generation and vision are the visual artifact loop. Mixing them in product copy creates implementation debt.
The Define Goal stack
The "Define Goal" skill should not be a slogan. It should create a series of goals, each with an owner thread, source receipts, status, artifact, and audit question. In Codex App terms, that is the bridge between a good prompt and parallel work that can be reviewed.
Goal dashboard for cooking with Codex
The standalone report artifact lives at
memory-bank/artifacts/codex-worlds-fair-cooking-2026-06-29/progress-dashboard.html.
Pull official docs, AIE schedule data, Agent Skills spec, and Convex receipts.
Done: source links and schedule v4844 captured.Decide Browser, Chrome, Computer Use, plugin, Realtime, or image/vision before acting.
Done: table shipped in this route.Build the public note and dashboard so a user can inspect the claim in the browser.
In progress until live-domain verification passes.Document Codex cloud and connected-host setup as separate execution paths.
Done: setup checklist below.Move reusable choices into skills/codex-cooking-workflow/references/.
Every spawned thread needs a blocker, artifact, verification command, and next repair step.
Queued: use this as the follow-up audit rubric.How to set up remote Codex execution
Codex has two different remote stories. Codex cloud runs tasks in configured cloud environments connected to a repository. Remote connections let a trusted host provide files, shell, tools, credentials, plugins, Browser, and Computer Use to another Codex surface. Treat them as different products.
Use Codex cloud for repo-contained work
Configure the environment at ChatGPT Codex settings, connect GitHub, define setup commands, secrets, caches, and domain allowlists, then launch tasks with logs, diffs, and reviewable outputs.
Use remote connections for a real machine
Keep the host awake, install and authenticate Codex App, pair mobile or desktop, and rely on SSH host entries for dev boxes. Do not expose the app-server publicly.
Make setup deterministic
A remote Chopshopr host needs bun install, bun run build,
MCP registrations, OpenAI docs access, deploy credentials, and local model health
checks documented as receipts.
Show status before delegation
The frontend dashboard should show source freshness, environment readiness, current goal, spawned thread, artifact path, and last verification command before the agent starts cooking.
The app-server protocol layer
If remote connections are the product experience, Codex app-server is the lower-level protocol surface for building a rich Codex client inside your own product. It is not the CI automation path; OpenAI's docs point automation jobs toward the Codex SDK instead. App-server is for authentication, conversation history, approvals, streamed agent events, and thread/turn control.
Treat app-server as a private control plane. Put product auth, tenancy, audit logs, and user-visible status in Chopshopr. Keep raw app-server listeners local, on a Unix socket, behind stdio, behind SSH port forwarding, or behind explicit WebSocket auth and TLS. Never expose an unauthenticated non-loopback listener as the product API.
off.
Chosen listener, local binding, token/TLS story, and health probe result when WebSocket is used.
initialize, then the initialized notification.
Client name, version, capabilities, and any notification opt-out recorded in logs.
turn/completed state.
Best practices for everybody building on AI
- Choose the tool plane before the model plane. Bad surface selection creates most demo friction.
- Make every appshot actionable: current state, intended action, safety boundary, and expected receipt.
- Prefer structured plugins and connectors before UI automation when a trustworthy API exists.
- Use app-server for rich product clients only after you can explain transport, auth, lifecycle, event streaming, backpressure, and schema versioning.
- Use Computer Use for real desktop surfaces, and keep screenshot detail original for click accuracy.
- Keep voice, image, and browser demos separate until each one has its own verification path.
- Promote every repeated lesson into a skill reference with scripts or assets when possible.
- Let progress dashboards show the audit trail, not just a pretty completion percentage.
Questions for the end reasoner
The move is not from one better prompt to one larger agent. It is from prompting an agent to designing the loop the agent can keep running, auditing, and improving.
Have I tried asking Codex to do it?
Give Codex the artifact, the success test, the allowed tools, and the permission boundary. If it still stalls, the blocker is probably not model intelligence.
What is stopping Codex from getting to the answer?
Classify the failure: missing source, hidden state, unavailable environment, unsafe action, absent test, or ambiguous taste call. Each class gets a different repair.
Why does this process need a human at all?
If the human is only applying a repeatable preference, encode the rubric. Keep the human where taste, accountability, access, or irreversible action is actually the job.
How do I move from prompting agents to building loops?
Convert the prompt into a DMAIC loop: define the goal, measure the current state, analyze the blocker, improve the artifact, and control recurrence with a skill, test, or dashboard.
How do I scale from one agent to many?
Split by artifact boundary, not vibes: source scout, implementer, reviewer, browser verifier, deploy verifier, and goal auditor. Merge only through receipts.
How do I build the machine that builds the machine?
Promote the winning loop into skills, scripts, app-server events, progress data, search entries, smoke tests, and reports that sibling projects can run without the original author in the room.
The related Chopshopr threads are already pointing at the same operating system: Skillable is scalable for reusable skills, Nothing left inside the tool call for action preflight, Applause instead of adoption for explicit state and authority, Arthasida Frontier Console for control-loop review, and Reasoning Quality Lab for turning human methods into package gates.
The demo to cook first
The smallest useful browser demo is the one this route now carries: a source-backed blog post, generated visual, tool chooser, goal dashboard, report artifact, search entry, smoke-test needles, and a reusable skill reference. It is not the flashiest possible Codex demo. It is the one another project can absorb tomorrow.
bun run build
open https://chopshopr.ai/blog/cooking-with-codex-worlds-fair/?v=20260629
open https://chopshopr.ai/search/?q=codex%20cooking%20dashboard
The local build proves route, search, smoke, and tests. The live open proves the deploy. The search query proves the learning is discoverable instead of buried.