Using OpenAI Codex CLI with GPT-5-Codex: How I Turned a Single-Player Demo into a Live Multiplayer Game

📣 Lead: What I announced and why it matters

I'm Romain Huet, and in a short demonstration I walked through how to use the Codex CLI together with GPT-5 Codex to extend a small game into a multiplayer experience — without writing a single line of manual code. The demonstration featured Eason Goodale and highlighted a number of updates we've shipped for Codex CLI that make agentic coding workflows fast, safe, and practical for real development tasks.

This article reports on that demonstration as a news-style guide: what we released, how the workflow looks in practice, the commands and safety controls I used, and how you can apply the same approach to your projects. I’ll walk you through installing the CLI, planning features with GPT-5 Codex, switching models and modes, approving changes safely, deploying to Vercel, and playing the live multiplayer game we produced in minutes. Along the way I’ll explain the deeper capabilities — from sandboxing to long-running agentic sessions — and share practical recommendations for teams adopting Codex CLI.

🗂️ Executive summary

In brief: we shipped GPT-5 and GPT-5 Codex, and the Codex CLI received updates that make it easier to use the model as an agentic coding teammate directly from the terminal. With just a few commands I was able to:

• Install and log into Codex CLI with a ChatGPT account.
• Ask GPT-5 Codex to create a plan for converting a single-player game into a multiplayer one.
• Use transcript mode to inspect chain-of-thought and exact code changes.
• Switch models to balance speed and reasoning power.
• Change approval modes (read-only, auto, full access) to manage sandboxing.
• Deploy the app to Vercel using the CLI and relevant deployment helpers.
• Play the live multiplayer game with another person in real time.

📰 Why this matters (the news angle)

This demonstration is notable because it showcases a practical, end-to-end developer experience where a state-of-the-art coding model not only generates code but acts as an agent that plans, edits, tests, and deploys an application — all from the terminal. That capability changes typical development workflows by reducing the friction between ideation and running software. It also emphasizes safety and control via approvals and sandboxing, which are crucial for real-world adoption.

🔧 Installation & login 🚀

Getting started is intentionally simple. I demonstrated that the Codex CLI can be installed via standard package managers (npm or Homebrew) and then authenticated using your ChatGPT account. The goal here is to let developers use the tools they already have in their local environment without a complicated setup.

Step-by-step, the flow I used is straightforward:

1. Install the Codex CLI using your preferred package manager (npm or brew).
2. Log in with your ChatGPT account so the CLI can securely access the models and your subscription.
3. Open a terminal and launch the Codex session (I referenced launching the CLI from the terminal).

That lightweight setup means teams can put Codex CLI into existing workflows fast. If you already use package managers and a terminal-based workflow, Codex CLI feels like a native addition rather than a new, heavyweight toolchain.

🧭 Planning a multiplayer implementation 🧠

One of the most powerful moments in the demo was watching GPT-5 Codex generate a plan for converting a small single-player demo into a multiplayer game. I prompted Codex to "make a plan for making this game multiplayer," and the model returned a clear step-by-step approach, including the files to change, the networking approach, and how to handle state synchronization.

Two things are important to call out:

• The plan is not just high level; GPT-5 Codex provided actionable steps that can be executed by the CLI agent to modify the codebase.
• The initiative here demonstrates the agentic capability: the model isn't just giving instructions for a human to follow — it's preparing changes it will execute once authorized.

When you ask Codex for a plan, you get both a design blueprint and a concrete roadmap. For teams that want to move quickly from idea to running software, that combined view significantly reduces overhead in the early design and prototyping stage.

🖥️ A quick tour of the CLI commands and modes 🧰

During the demo, I walked through several commands and modes that are central to an effective Codex CLI workflow. Below I summarize the most useful features and how I use them in typical sessions.

Model switching for task-appropriate performance

I used the slash-model feature in Codex CLI to switch models mid-session. The rationale is simple: different models are optimized for different tasks. For example, algorithmic reasoning and deep debugging may benefit from a stronger reasoning model like GPT-5 Codex, while trivial edits or high-throughput simple tasks can be handled by a faster, lighter model.

Switching models is a practical way to manage latency and cost while preserving the quality of the results you need. In my workflow I frequently switch between a "fast" model for scaffolding and a "deep reasoning" model for complex design, refactors, or when I need the agent to run for longer periods.

Approvals and sandboxing modes

One of the most important safety and workflow controls in the CLI is the approvals system. We designed it with three modes that align with different stages of trust and project maturity:

• Read-only — Useful when I only want the model to inspect code or produce a plan without making any changes to files. This mode is especially handy for audits, design sessions, or when I'm working outside a Git repository.
• Auto — The default. In auto mode the agent can read files and make edits within the current project directory. This keeps the agent constrained to the project boundary so it won't affect unrelated files on your machine.
• Full access — Grants the agent expanded permissions if you explicitly need it to run build or deployment tooling that requires broader access. I used full access briefly during deployment steps that needed to call external CLIs and write temporary state.

These approval modes let you adopt agentic workflows incrementally: start with read-only to see what the model recommends, move to auto to allow safe, project-local edits, and use full access only when necessary and after due diligence. In the demo I switched to full access specifically to deploy to Vercel from the CLI — a deliberate, short-lived change of permissions.

Transcript mode for transparency (Control-T)

Transparency is essential when an agent is acting autonomously on your code. When you press Control-T, the CLI enters "transcript mode." I used this mode in the demo to show the chain-of-thought and the exact drafts and patches the model was preparing. That includes intermediate reasoning steps and the concrete diffs the agent intends to apply.

Transcript mode is invaluable if you are auditing changes, debugging why the agent made a particular edit, or teaching colleagues how to best interact with the model. It surfaces the model's intermediate reasoning and the precise code patches so you can approve changes with full context.

🔍 Implementing the plan: agentic edits in practice ✍️

After Codex generated a plan for the multiplayer conversion, I asked it to execute the plan. The model took the steps it had outlined and began making targeted edits inside the project directory. Because the CLI was in auto mode, it was allowed to edit files within the repository boundaries. I then inspected the changes using transcript mode and let the agent proceed.

What happens in this execution phase is worth describing in detail because it demonstrates the shift from passive generation to active, agent-driven development:

1. Plan generation: Codex produces a multi-step plan that identifies code paths, new modules, and test cases to add.
2. Change preparation: the agent drafts the code changes as patches or new files, and shows them in the transcript so you can review them before they are committed.
3. Execution: once approved or set to auto, the agent applies changes to files, runs tests locally, and iterates if failures occur.
4. Verification: the agent can run the test suite, linting, or a quick local server to validate the changes are functional.

In the demo, Codex modified networking logic, added a basic server endpoint to coordinate players, and introduced state-synchronization logic so the ball's position would be shared across clients. All of this was done via the CLI, with me supervising the process and using the built-in sandboxing controls.

This pattern — plan, draft, execute, verify — is the agentic loop I recommend teams adopt. It reduces context switching, keeps changes small and reviewable, and lets the model shoulder repetitive tasks while the human retains final control.

📦 Deploying the game to Vercel ☁️

Once the multiplayer changes were in place and verified locally, I wanted to deploy the app so we could actually play together. In the demo we used Vercel as the hosting target because it's lightweight for frontend + serverless flows and integrates well with typical modern JavaScript stacks.

The sequence I used to deploy was as follows:

1. Change approvals to full access temporarily so the CLI agent could call the Vercel CLI and create a deployment.
2. Ask the agent to look up the latest Vercel docs if needed (we used the WebSearch capability for this) to ensure the deployment commands and flags were current.
3. Use the Vercel CLI through the agent to create a new deployment. The agent issued the commands, uploaded the built artifacts, and returned a URL once the deployment completed.

Because the CLI can call external tools and reference live documentation, deployment becomes a continuation of the development loop rather than a separate, manual process. I emphasized in the demo that this same flow is how I handle more serious production tasks too — the agent can take you from local changes to a deployed instance quickly, while you remain in control of the permissions and the review process.

🎮 Playing the game: live multiplayer in seconds 🕹️

After deployment, Eason and I opened the deployed URL and joined the same session to play the game. The multiplayer synchronization we had asked Codex to implement allowed both of us to interact with the shared state in real time. It felt like a natural conclusion to the end-to-end workflow: from idea to live shared experience in minutes.

That final step demonstrates an important cultural shift: building small experiments and sharing them with collaborators is dramatically faster when the model can make and validate changes automatically. For teams running rapid prototyping sprints, this can accelerate feedback cycles and raise the cadence of iteration.

🔁 Using WebSearch and external docs 📚

An understated but important capability I used in the demo was the model's ability to fetch relevant documentation and examples from the web via the WebSearch feature. When you're implementing a new integration (for example, a Vercel deployment or a third-party SDK), the model can look up the latest API names and usage examples and incorporate them into the plan or the code it generates.

That reduces the need to manually search for integration details and paste snippets into your editor. Instead, the agent synthesizes the external documentation into a targeted change set, which you can then review in the transcript. When combined with the approvals and sandboxing controls, this makes it safe and convenient to incorporate up-to-date external guidance into your projects.

🛡️ Sandboxing, security, and approvals: practical guidance 🔐

When adopting an agent that can modify your code, safety and governance are paramount. I walked through a few practical rules I use to stay safe:

• Start with read-only mode for exploration. Let the agent explain what it would change and why before granting write access.
• Use auto mode for normal development where the agent works only within the current project directory. That prevents accidental edits to unrelated files on your machine.
• Reserve full access for short, auditable tasks like deployments. Revoke or reset permissions after the action completes if your workflow requires tighter control.
• Use transcript mode to inspect chain-of-thought and the exact diffs. If something looks surprising, revert the change and ask the agent to explain its reasoning.
• Put code reviews and CI gates in place for production branches: even if the agent is confident, human review remains essential for safety-critical or customer-facing changes.

These steps let you scale agentic productivity without sacrificing control. The CLI was explicitly designed to make these guardrails straightforward and visible so teams can adopt them incrementally.

🔬 Long-running sessions and advanced agent behavior ⏳

Another capability I highlighted in the demo is that Codex can handle longer-running reasoning and iterative workflows. You can set the agent to work on a complex refactor or debugging task that may take minutes or hours of back-and-forth thinking. For those scenarios, model selection matters: pick a model optimized for longer reasoning if you want deep analysis, and switch to a faster model for routine tasks.

For example, debugging a complex concurrency issue or designing a nuanced synchronization protocol for multiplayer logic benefits from a model that can maintain a longer context and run through many iterations. Codex CLI supports picking the right model per task and resuming previous sessions with the "Codex Resume" feature so you don't lose progress.

📈 Real-world use cases beyond demos 🧩

While the demo focused on a small game, the same pattern applies to a wide range of development activities. Here are a few concrete examples where I find agentic CLI workflows especially productive:

• Rapid prototyping: Turn design prompts into working prototypes quickly and iterate with the agent.
• Bug triage and resolution: Ask the agent to scan logs, reproduce errors locally, propose fixes, and apply patches with CI checks.
• Integration and migration: Let the agent read external docs, prepare migration scripts, and run tests to lower migration risk.
• DevOps and SRE tasks: Use the agent to analyze monitoring data and produce remediation steps, or to run scripted rollouts in coordination with human oversight.
• Documentation and onboarding: Generate project-level documentation and onboarding guides, and have the agent add READMEs and example snippets automatically.

These are not theoretical use cases. In my day-to-day I use the same flow the demo shows to accelerate a wide spectrum of engineering tasks across languages and frameworks.

🧭 Best practices for team adoption ✅

If you're introducing agentic tooling like Codex CLI to a team, here’s a playbook I’ve found effective from early adopters:

1. Start small with non-critical tasks: use the agent for documentation, scaffolding, or small bug fixes before moving to larger code changes.
2. Define permission policies: decide when to use read-only, auto, or full access and who can toggle those modes for a project.
3. Use transcript mode for onboarding: show new team members how the agent reasons and modifies code, which demystifies the process and builds trust.
4. Keep tests and CI gates: automatically enforce test coverage and linters before merging any agent-made changes into protected branches.
5. Establish code-review workflows: require human sign-off for production changes, but allow the agent to do the heavy lifting under reviewer supervision.
6. Log agent activity: capture the transcripts and the diffs in your audit logs so you can trace changes back to the agent session.

These steps maintain velocity without sacrificing quality or governance. Codex CLI is designed to fit into that model by making the controls visible and easy to use.

🧾 Example session transcript highlights (what I actually said) 🗣️

To give a clearer picture of the flow, here are some paraphrased highlights from the session I ran with Eason:

• I opened by saying, "Recently, we shipped GPT-5 and GPT-5 Codex, and we've also released a ton of improvements to Codex CLI." That sets the context: improved model, improved CLI tooling.
• Eason chimed in to show the install and login flow: "You can install it really easily with either npm or Brew and log in with your ChatGPT account."
• I asked the tool, "make a plan for making this game multiplayer," and watched as it laid out the steps and the files to change.
• We used transcript mode (Control-T) to make the chain-of-thought visible and inspect the exact edits the agent prepared.
• Eason emphasized the model switcher: "You sometimes want to use one model for one thing, one model for another," which is great advice for trading off speed and reasoning power.
• We changed approvals to full access temporarily and asked the agent to deploy to Vercel. Within minutes we had a live URL and were playing together.

These lines capture the real-time nature of the session and how the CLI ties together planning, editing, and deployment into a single, auditable loop.

🔧 Troubleshooting common issues and tips 🛠️

Here are a few practical tips and common pitfalls I encountered and corrected during the demo and subsequent internal testing:

• Agent misunderstandings: Occasionally the agent's first plan misses a detail. Use transcript mode to spot these and ask the model to adjust the plan or revert an edit. The interactive loop makes corrections easy.
• Network or CLI dependencies: If external CLI tools (like the Vercel CLI) are required for deployment, ensure they are installed and accessible in your environment or let the agent show the missing prerequisites.
• Large repositories: In very large monorepos, point the agent to a specific subdirectory to keep changes scoped and reasoning focused.
• Test flakiness: If the agent runs tests and some are flaky, annotate the test suite so the agent can understand test constraints or reproduce the failure locally before fixing.
• Permission creep: When using full access for deployments, revoke elevated permissions after the action completes if your organization requires it.

Most issues are resolved by combining a brief human review with the visibility tools (transcript, diffs, logs) built into the CLI.

🏛️ Governance and compliance considerations 📜

Organizations will naturally ask about governance: how do we ensure agent-made changes are compliant with policies and secure? Here are the levers I discussed and recommend:

• Audit logging: Keep transcripts and diff history associated with commits and deployments to explain where a change came from.
• Least privilege: Use the smallest permission mode needed for a task and require explicit elevation for broader access.
• CI gates: Require tests, linters, and static analysis to run before merges to protected branches.
• Human-in-the-loop: Define which changes require human review and which the agent can autonomously apply in low-risk areas.
• Policy enforcement: Integrate policy checks that examine the agent's patches for disallowed patterns (secrets, unsafe dependencies, hardcoded credentials, etc.).

With these controls in place, teams can get the productivity benefits of agentic tooling while meeting governance and compliance requirements.

🔭 Looking ahead: the future of agentic coding workflows 🚀

The demonstration is a clear signpost for how developer tooling evolves. Rather than replacing developers, agentic tools are amplifiers. They take on the repetitive parts of engineering — scaffolding, implementation of routine features, searches across codebases — so developers can focus on higher-level design and system thinking.

Some practical developments I expect to see soon:

• Tighter IDE integrations so the same agentic flows in the CLI are available in graphical editors with the same approvals and transcript transparency.
• Improved multi-agent coordination where separate agents handle frontend, backend, and infra tasks and coordinate through secure contracts.
• Expanded preflight checks and policy layers that enforce organizational standards before agents can apply changes.
• More sophisticated session resumption: agents will keep richer context across interruptions and integrate seamlessly with project management tools.

These advances will further compress cycle time between idea and production while giving organizations more control and observability over automated actions.

📣 Conclusion: what I want developers to take away 📝

Here are the core takeaways I want you to keep in mind:

• Codex CLI + GPT-5 Codex makes agentic development practical from the terminal: plan, implement, test, and deploy with the agent as a teammate.
• Safety is built in through approvals and transcript mode; adopt least privilege and require human review where necessary.
• Model selection matters: use faster models for routine edits and stronger reasoning models for complex design or debugging tasks.
• Deployment can be part of the same interactive loop; the agent can call CLIs and use web documentation to keep your workflows current.
• This approach accelerates prototyping and repetitive work, freeing engineers to focus on higher-value decisions.

If you want to try the same flow, start by installing the Codex CLI, log in with your ChatGPT account, and run a simple experiment like asking Codex to make a plan for a small feature. Use transcript mode to learn how the model reasons, and gradually allow the agent to make project-local edits in auto mode. When you need to deploy, temporarily elevate permissions with care and follow the same audit and review practices you use for human PRs.

📢 How to get started right now (resources) 🧭

To explore this workflow yourself, here are the official starting points I referenced during the session and recommend visiting:

• Codex landing page: openai.com/codex
• Codex CLI GitHub repository: https://github.com/openai/codex
• Developer documentation and API: developers.openai.com/codex

These resources contain installation instructions, examples, and policy guidance to help teams adopt Codex CLI safely and productively.

🗞️ Final note — a personal perspective from the demo floor 🧑‍💻

Demonstrating this flow with Eason was energizing because it made concrete what many developers feel: that the barrier between idea and running software can still be much lower. Watching an agent draft a plan, apply edits, run tests, and produce a live deployment in minutes is not just a novelty — it’s a preview of a new, practical class of developer tooling.

That said, this isn't a magic bullet. It’s a productivity multiplier when you combine it with good engineering practices: tests, CI, human review, and thoughtful permissions. The tools we've built in Codex CLI — model switching, transcript mode, approvals — are designed to support that responsible adoption path.

I encourage you to try the flow on a small project, experiment with the approvals modes, and use transcript mode early so you can see how the agent is reasoning. With those guardrails and a curious approach, you can accelerate routine work and free more time for the creative, high-impact engineering that still needs human judgment.

Thanks for reading — and I can’t wait to see what you build with Codex CLI and GPT-5 Codex.