OpenAI Codex Workshop for Teams: CLI, Cloud Tasks and AGENTS.md

Plan an OpenAI Codex workshop for your team: local CLI work, delegated cloud tasks, AGENTS.md conventions and a pull request review workflow that scales.

Short answer

An OpenAI Codex workshop should teach two working modes side by side: interactive work with the local CLI and delegated tasks that run in the cloud and return as pull requests. AGENTS.md ties both together, and a clear review workflow keeps the volume of agent pull requests manageable.

On this page
  1. Two ways of working, one team
  2. Learning goals
  3. Workshop structure
  4. Choosing tasks to delegate
  5. Organizational questions to answer up front
  6. After the workshop
  7. FAQ
  8. Tools from the jocapps ecosystem

Two ways of working, one team

OpenAI Codex is used in two quite different ways. Locally, engineers run the Codex CLI or the editor integration and steer the agent interactively, much like pairing. In the cloud, they hand off a task, the agent works on it in an isolated environment, and the result comes back as a diff or pull request to review. Teams that only learn one mode miss half of the value, and teams that use the cloud mode without a review plan quickly find themselves with a queue of pull requests nobody wants to read.

The workshop format below, which we run at neooutput, treats both modes as complementary and spends as much time on review as on generation.

Learning goals

By the end, every participant should be able to:

  • Set up the Codex CLI on their machine and work with it on a real repository
  • Write and maintain an AGENTS.md file that both local and cloud runs pick up
  • Decide which tasks are suitable for delegation and which need interactive steering
  • Prepare a cloud environment so delegated tasks can install dependencies and run tests
  • Review agent pull requests efficiently and give feedback that improves the next run

Workshop structure

Part one: the local CLI (half day)

We begin locally because the feedback loop is fastest. Participants explore the repository with the CLI, make a small change and run the tests. We cover approval modes, how much autonomy to grant for which kind of task, and how to keep the agent inside the working directory. Typical exercises:

  1. Explain an unfamiliar module and draw its dependencies in a text diagram
  2. Fix a known bug and add a regression test that fails before the fix
  3. Rename a concept across the codebase and verify nothing else changed

Part two: AGENTS.md as shared memory (two hours)

AGENTS.md is a plain Markdown file in the repository that tells coding agents how the project works. Because it is an open convention read by several tools, effort spent here is not locked into one vendor. Participants write sections on:

  • Setup and test commands, including how to run a single test file
  • Code style and patterns the linter does not catch
  • Directory responsibilities and boundaries
  • Pull request expectations: title format, description, what must be included

Nested AGENTS.md files in subdirectories can hold module-specific rules. Our dedicated CLAUDE.md and AGENTS.md workshop covers this topic in depth for teams using several agents.

Part three: delegated cloud tasks (half day)

Cloud tasks need an environment the agent can actually work in. We configure it together: which setup script installs dependencies, which environment variables are safe to provide, and what network access the task may have. Then each participant delegates two or three tasks from the backlog and continues with other work while they run.

When results come back, we compare them. Why did one task succeed and another drift? Usually the answer is in the task description: missing acceptance criteria, an ambiguous scope or a test the agent could not run. Participants rewrite the weak task and run it again.

Part four: the pull request review workflow (two hours)

This is where teams win or lose. We agree on rules such as:

RuleWhy it matters
One task, one pull request, one concernKeeps diffs reviewable
The agent writes the PR description with a risk sectionReviewers know where to look
Tests must run in the task environment and be greenNo "works on the agent's machine"
A named human owns every agent PRAccountability does not move to the tool
Rejected PRs get a short reason added to AGENTS.md if it is a patternThe next run learns

We also practise using an AI review pass as a first filter, while keeping a human decision on merge. The broader topic of review tooling is covered in our article on AI code review tools.

Choosing tasks to delegate

A simple heuristic we teach: delegate when the task is well specified and verifiable, steer locally when it is ambiguous or touches design decisions.

Good candidates for delegation:

  • Test backfills for existing, stable modules
  • Dependency upgrades with clear changelogs
  • Repetitive changes across many files following a pattern
  • Small bugs with a reproducible test case

Better kept interactive:

  • New features where the design is still open
  • Performance work that needs profiling and judgement
  • Anything touching authentication, payments or personal data

Organizational questions to answer up front

Codex in a team setting raises the same questions as any agentic tool: which workspace or plan, which repositories may be connected, who may trigger cloud tasks, and how secrets reach the task environment. Settle these with security before the workshop. If the answers take longer, run the workshop on a non-sensitive repository first so the skills are ready when approval arrives.

After the workshop

Teams usually see the biggest gains in the weeks after the session, when they refine AGENTS.md based on real failures. We recommend:

  1. A weekly 20-minute slot to review the most instructive agent PRs
  2. A visible owner for AGENTS.md per repository
  3. A short metrics check after six weeks: merged agent PRs, rework rate, review time

Some organizations find they want more delivery capacity than their own team can provide, even with agents. For those cases, OnlineAppCreator offers done-for-you engineering by AI Code Engineers with SLAs, using the same agentic practices.

neooutput runs the Codex workshop in English or German, remote or on site, and can combine it with a Claude Code track for teams evaluating both. If that comparison is on your mind, read Claude Code vs OpenAI Codex first.

FAQ

Is AGENTS.md specific to Codex?

No. AGENTS.md is an open convention that several coding agents read. Investing in it benefits Codex and other tools that support the format, which makes it a safe choice for mixed-tool teams.

Do cloud tasks replace the local CLI?

No. They solve different problems. Cloud tasks are best for well-defined, verifiable work you can run in parallel. The local CLI is better for exploration, design decisions and anything that needs tight steering.

How many people can join one workshop?

We recommend 6 to 16 participants working in pairs. Larger groups are possible with a second trainer, but the review exercises lose depth.

What if our repositories cannot be connected to a cloud service yet?

We run the cloud part on a sanitized or open-source repository and the local part on your real code. The skills transfer once approval for production repositories is in place.

Tools from the jocapps ecosystem

Want this done right, and fast?

Talk to our AI Code Engineers and AI architects. In a free 30-minute call we look at your idea, prototype or roadmap and tell you honestly what it takes to ship it.

24/7 call support in English and German.

Free call

Free intro call

Tell us which task an AI agent should take responsibility for. We show how our platform, AI Code Engineers and operations plug into your stack.

  • 30 minutes, no obligation
  • Honest feasibility check
  • Concrete next step
Rather talk now? 24/7 call support in English and German+49 761 519 751 50