Missing feature chatgpt to codex and codex to chatgpt

[chrisallen12789]

I am currently using the Codex App to build a Windows application. One of my Codex tasks has been running autonomously for more than nine days and has involved hundreds of subagents, repeated validation cycles, code changes, independent audits, Windows process testing, compilation work, manifests, WMI testing, and release infrastructure.

During this process I discovered a significant workflow gap between ChatGPT and Codex.

I regularly use ChatGPT as an independent reasoning layer to help me understand what Codex is doing. ChatGPT is very useful for interpreting the technical status, explaining failures, evaluating whether the development process is converging, and helping me decide whether Codex is productively hardening the application or over-engineering it.

However, ChatGPT cannot inspect the active Codex task.

My current workflow is literally:

Codex → screenshot → upload screenshot to ChatGPT → ChatGPT analyzes it → repeat

I have done this repeatedly throughout a multi-day Codex run.

This works, but the user is effectively being forced to act as the integration layer between two OpenAI products.

Proposed Feature

Allow a user to explicitly grant a ChatGPT conversation read-only access to a selected active Codex task.

I am not asking for ChatGPT to automatically control Codex.

The initial capability could be entirely observational.

For example, I would like to be able to tell ChatGPT:

«Inspect my active Lane Audio Lab Codex task. Tell me what Codex is currently working on, what has actually been completed, what is blocking it, and whether the run appears to be converging or repeatedly revisiting the same work.»

With explicit authorization, ChatGPT could then inspect the selected Codex task and answer that question.

Read-Only Information That Would Be Useful

Ideally, the authorized view could expose some combination of:

• Current task objective
• Current plan and phase
• Task/session history
• Completed and remaining work
• Recent actions
• Subagent activity and summarized results
• Files being changed
• Git diffs
• Commits
• Test results
• Compilation/build status
• Current blockers
• Errors and failed attempts
• Validation/audit results
• Build artifacts
• Packaging/install status
• Decisions made by the agent
• Current next action

This does not necessarily require exposing every raw token or internal implementation detail. A structured task-state API or task summary could potentially provide enough information.

Why This Matters

Long-running autonomous development changes the observability problem.

A simple progress indicator such as:

Step 4 of 8

isn't sufficient when an agent can dynamically create new plans, launch hundreds of subagents, perform repeated validation cycles, discover new blockers, or spend substantial time building supporting infrastructure.

The user eventually needs to answer higher-level questions:

Is this actually progressing?

What has been built?

What is Codex spending its time on?

Is it fixing product problems or its own development infrastructure?

Is the current blocker significant?

Should I let the autonomous run continue or intervene?

ChatGPT is particularly well suited to answering those questions, but currently it can only reason from whatever information the user manually transfers from Codex.

Real-World Example

My current application is still private pre-alpha software.

The immediate objective is to get it into the hands of two trusted testers so we can determine what works, what we dislike, what is missing, and what the application should ultimately become.

During a nine-plus-day Codex run, Codex began constructing increasingly sophisticated validation and release infrastructure.

Some of that work could be extremely valuable if the application eventually becomes a distributed product.

But as the user, I needed help answering a different question:

Is Codex building valuable long-term infrastructure, or has it started over-engineering a pre-alpha application before the humans have even tested the product?

ChatGPT has been helping me reason through that question by analyzing screenshots.

It would be substantially more useful if, with my permission, ChatGPT could inspect the actual Codex task.

Permission Model

This should be explicitly controlled by the user.

For example:

Share Codex Task with ChatGPT → Read Only

The user could select:

• Which Codex task
• Which ChatGPT conversation
• What information can be accessed
• How long authorization lasts

Access should be revocable at any time.

A visible indicator could show when a ChatGPT conversation has access to a Codex task.

Potential Future Extension

Read-only observability would solve the immediate problem.

Later, the same architecture could potentially support explicit actions such as:

Ask ChatGPT to review this Codex plan

Ask ChatGPT whether Codex appears stuck

Ask ChatGPT to summarize the last six hours of Codex work

Ask ChatGPT to recommend whether the user should intervene

Eventually, users could potentially authorize ChatGPT to send guidance back to Codex, but that is not required for the core feature.

The valuable first step is simply allowing one OpenAI reasoning surface to understand what another OpenAI agent is doing when the user explicitly authorizes it.

Summary

Today:

Codex → user manually transfers information → ChatGPT → analysis

Proposed:

Codex → permissioned read-only task state → ChatGPT → analysis

As Codex tasks become longer-running and more autonomous, I think this type of cross-product observability becomes increasingly important.

The user should not have to photograph one OpenAI product so another OpenAI product can understand what it is doing.