How to make Codex proactive

What “proactive” means for Codex

Out of the box Codex answers when you ask. A proactive setup needs three things, and they live in different parts of the product:

• It doesn't stop for every approval: a permission mode that lets routine actions through.
• It starts on its own: a scheduled task, an event trigger or a cron job that begins work without you.
• It knows what to do next: a backlog and a goal, so every run has useful work.

Step by step: make Codex proactive

1. Choose a permission mode that doesn't stop for everything

   In the CLI, type /permissions. “Approve for me” only asks about actions detected as potentially unsafe, which suits work you aren't watching. “Full access” removes the limits on files and the internet; keep it for isolated machines. If an older guide tells you to use --full-auto, that flag is no longer supported: use --sandbox workspace-write instead.

   /permissions

2. Create a scheduled task (formerly Automations)

   What used to be called Codex Automations is now Scheduled tasks. Ask for one in a Codex chat: say what the work is, when it should run, and whether results come back to the same chat. Tasks can run every few minutes, daily or weekly, and you manage them in the Scheduled view in the sidebar. A task that works on local files needs the computer on and the app running; in a Git repository it can work in a separate background worktree. The Codex CLI doesn't manage scheduled tasks.

   Every weekday at 9am, check this repo for failing tests,
   fix what you can in a background worktree,
   and post a summary in this chat.

3. Trigger tasks from events

   Instead of a time, a task can start when something happens: a new Gmail message, a Slack message in channels you choose, or activity on a GitHub pull request. Event triggers are set up from ChatGPT on the web or mobile, on eligible plans, and a task uses either events or a schedule, not both.

4. Run Codex from cron with codex exec

   codex exec runs Codex without the interactive interface: progress goes to stderr and only the final message to stdout, so it fits scripts and scheduled jobs. It's read-only unless you pass --sandbox workspace-write. OpenAI's docs list scheduled jobs as a use but don't give a cron example; this one is ours.

   # crontab -e: every weekday at 9:00
   0 9 * * 1-5  cd ~/my-app && codex exec --sandbox workspace-write "Fix any failing tests and summarize what you changed" >> ~/codex-cron.log 2>&1

5. Put Codex in your GitHub workflow

   The openai/codex-action GitHub Action runs Codex inside a workflow, and you choose its triggers. On pull requests, comment @codex review for a review, or ask @codex to fix CI failures. In Linear you can assign an issue to Codex.

   # .github/workflows/codex.yml
   steps:
     - uses: openai/codex-action@v1
       with:
         prompt-file: .github/codex/prompts/review.md
         openai-api-key: ${{ secrets.OPENAI_API_KEY }}

6. Use hooks to react inside a session

   Codex hooks run your commands at points such as session start, before and after a tool call, or when a turn stops. They react while Codex is working; they don't start it. To start work, use a scheduled task or an event trigger.

Source: OpenAI's Codex documentation on scheduled tasks

Add a heartbeat: wake the same conversation for its next task

A heartbeat is a short, regular nudge into the same Codex conversation, such as every 30 minutes during working hours, that says: check your work, take the next task. A scheduled task repeats one prompt; a heartbeat keeps one conversation going, so Codex remembers what it did last time and picks the next item off a queue. That's the difference between a job that repeats and an employee that keeps working.

1. The closest built-in option

   A Codex scheduled task can send its results back to the same chat, so you can write its prompt as a heartbeat: “every 30 minutes, check TODO.md, take the next unchecked task and tick it off”. You still maintain the queue file yourself, and the schedule doesn't know about working hours or other agents.

2. With Crewmark: a heartbeat built in

   Crewmark's daemon queues the heartbeat into the employee's own Codex conversation with codex queue --resume every 15, 30 or 60 minutes during its working hours, and the board is the queue: each heartbeat, the employee takes its next issue and reports on it. Details are below.

And ChatGPT?

ChatGPT can reach out first, too. Scheduled tasks in ChatGPT send you reminders, recurring briefings and the results of things it monitors, and you'll find them on the Scheduled page in the sidebar. How many you can have and how often they run depends on your plan. ChatGPT Pulse, which sent a proactive daily update, was retired in June 2026; OpenAI points people to a scheduled task for a daily briefing instead.

The difference from Codex: a ChatGPT task works with what ChatGPT can reach, not with your codebase. For work in a repository, use Codex scheduled tasks or codex exec.

Which option fits

What these features still leave to you

Every option above starts a run. None of them decides what Codex should be working on this week:

• A scheduled task repeats one prompt. It doesn't pull the next item off a backlog or know what the last run left unfinished.
• There's no shared board where you hand Codex work and see what's in progress, done or blocked.
• There are no working hours or targets, so you can't ask it to move a number by the end of the month.
• Running Codex next to Claude Code means two separate sets of prompts, schedules and places to look.

Give Codex a standing job

Crewmark turns a Codex conversation into an AI employee with a role, a goal, working hours and a heartbeat, and gives it work through the same board as your Claude Code employees. It runs in your real Codex on the ChatGPT plan you already pay for.

1. Hire an employee and connect its Codex conversation

   Pick a role and run the setup command Crewmark gives you in Codex. That conversation becomes the employee, so it remembers the work between wake-ups.

2. Set working hours and a heartbeat

   The Crewmark daemon, a small background program on your computer, queues the employee's heartbeat prompt into that conversation with codex queue --resume every 15, 30 or 60 minutes during its hours, and leaves it alone outside them.

3. Assign issues on the board

   Assigning an issue or commenting on one sends the news into the same conversation, so Codex picks up new work on its own instead of waiting for you to paste it in.

4. Measure it on a number

   Give each employee a KPI. It plans its issues toward that number, moves them across the board, comments on progress and messages you when it needs a decision.

Use them together

Keep Codex's own scheduled tasks for small recurring chores and use Crewmark for the ongoing job: set the employee's conversation to “Approve for me” so each heartbeat gets work done, and let pull request reviews keep running through @codex review. On Claude Code instead? See how to make Claude Code proactive.

FAQ