How should a reliable multi-model / multi-agent workflow be built with ChatGPT and Codex?

This is not a complaint. I am sharing the result of a real experiment with ChatGPT and Codex and asking whether I am using the system incorrectly or whether an important capability is currently missing.

I am trying to build a reliable multi-model / multi-agent workflow.

The intended workflow is approximately:

User
→ ChatGPT understands the goal and maintains the overall project context
→ ChatGPT formulates a concrete engineering task
→ Codex executes the task
→ the result is returned and verified
→ ChatGPT and Codex continue from the verified state

In other words, I want different models/agents to cooperate on one task while sharing a persistent, validated state.

In practice, I could not make this reliable.

A concrete experiment exposed the problem.

We had an existing production application at version 0.2.1.

ChatGPT knew that the production target was 0.2.1 and helped formulate a task for Codex.

Codex correctly performed the technical modifications it was given, committed them, triggered GitHub Actions, and successfully produced an artifact.

However, that first artifact was built from version 0.2.0.

So each individual step appeared successful, but the multi-agent workflow as a whole was wrong.

The critical state:

TARGET VERSION = 0.2.1

was lost or was not enforced between reasoning, delegation and execution.

After discovering this, we repeated the process using the exact v0.2.1 source baseline.

The second build was technically correct.

This experience made me realize that I may be missing the intended way to construct a multi-model workflow with ChatGPT and Codex.

What I expected was something like a shared task state or execution contract:

GOAL
CURRENT VERIFIED STATE
TARGET
CONSTRAINTS
DO NOT CHANGE
ALREADY COMPLETED
ACCEPTANCE CRITERIA
RESULTS FROM OTHER AGENTS

Every participating model/agent should work against this same validated state.

If one agent proposes an action that contradicts it, the system should detect that before execution.

I do not want to manually copy the complete project state into every new Codex instruction, because that largely defeats the purpose of using cooperating agents.

So my questions are:

1. What is the recommended way today to build a reliable ChatGPT → Codex → ChatGPT multi-agent workflow?

2. Is there a supported mechanism for sharing persistent structured state between ChatGPT and Codex?

3. Can ChatGPT delegate a task to Codex while preserving hard constraints and acceptance criteria as machine-enforced state rather than ordinary prompt text?

4. Can the result of Codex execution automatically become verified state for the supervising model?

5. Is there an intended supervisor/worker architecture where one model plans and validates while another model executes?

6. If this functionality does not currently exist, is something like a shared Agent State / Task Contract / multi-agent orchestration layer planned?

The important point from our experiment is not the particular application or language model we modified.

The individual models were capable of solving the technical problem.

The failure occurred at the boundary between the models/agents.

That is the capability I am trying to understand:

How are users supposed to build reliable multi-model systems where several AI agents cooperate on the same real task without losing validated state between them?

If there is already a recommended architecture or feature for this in ChatGPT/Codex, I would appreciate guidance and an example.

More generally, this question is not specific to Codex.

The same problem appears whenever multiple models or agents are expected to cooperate on one real task: one model may plan, another may execute, another may verify, but they need a common trusted state that survives transitions between them.

So the broader question is:

Is there currently a way to eliminate or substantially reduce this problem when building multi-model / multi-agent systems?

Is there an existing OpenAI mechanism, architecture, API, shared state, orchestration pattern, or recommended practice that allows multiple models/agents to work from the same persistent and validated task state without requiring the user to manually repeat and verify all critical constraints at every handoff?

If such a mechanism already exists, I would very much appreciate an example of how this workflow should be built correctly.

If it does not exist yet, I think this may be an important missing capability for practical multi-agent systems.

The issue names no files, tests, or entry points. Start by determining whether the request belongs in Codex and narrowing the desired shared-state or orchestration capability; done should be a scoped implementation proposal with explicit constraints and acceptance criteria.