Using Astra + Codex + Computer Use + Pro + Deep Research as a self-orchestrating research organization

[Traum]

I think I accidentally turned ChatGPT/Codex into a small research organization.

Not with LangGraph/CrewAI/etc. Mostly just with persistent chats, Codex, Computer Use, Deep Research, stronger models, and a fairly strict orchestration prompt.

I have one main agent I call Astra.

The important difference is that I don’t tell Astra something like:

1. ask agent A

2. then ask agent B

3. then review

4. then continue

Instead I give it rules for how research should be conducted, and it decides what to do next.

For example it can decide that:

• a calculation should be delegated;

• an important result needs an independent reproduction;

• a reasoning bottleneck should be escalated to a stronger model;

• external sources are needed;

• a result is not solid enough to build on yet;

• something needs independent review;

• or a result is good enough within a specific scope and can be frozen.

Then it chooses the next bottleneck and keeps going.

Roughly:

Human
  ↓
Astra
  ├── Codex / workers
  ├── independent reproductions
  ├── stronger models
  ├── Deep Research
  ├── Computer/Browser Use
  └── separate ChatGPT referee

The separate referee has been especially useful.

I keep another persistent ChatGPT project/thread that is basically not allowed to be part of the original derivation. Its job is to attack major results.

Astra uses Computer Use to go there, posts the derivation/evidence, gets objections, comes back, fixes whatever is wrong, and resubmits.

So a real run can look like:

derive
→ reproduce independently
→ referee says no
→ fix
→ referee still has one blocking objection
→ fix that
→ accepted for a limited scope
→ freeze
→ move to next problem

This sounds obvious written down, but it feels very different from just asking one model to “critique your answer”.

The reviewer has its own persistent context and doesn’t automatically inherit all the assumptions of the main research thread.

One of the first things that convinced me this was actually useful happened on a software task.

Astra delegated implementation to Codex.

Codex returned successfully. Exit code 0. Looked done.

Astra checked the actual requested artifact.

It wasn’t there.

So Astra rejected the implementation and sent it back.

The second time it didn’t just trust the completion message either. It checked runtime behavior, tests, Git state, and what had actually modified the repo before accepting it.

That was a pretty good “oh, this might actually work” moment.

I later tried the same setup on a theoretical physics project.

It made its way through a two-loop calculation, independent reproduction, another analysis over the full profile, multiple rounds with the external referee, froze the part that survived review, and then picked the next matching problem.

I wasn’t manually copying every result between agents.

That’s really the thing I care about.

Not whether “AI can do physics” or whether running 10 agents is impressive.

I’m interested in whether the coordination itself can become autonomous.

Right now one hacky part is communication between persistent ChatGPT projects.

There isn’t really a clean native project-to-project handoff, so I’m using Computer Use / Browser Use as a ridiculous integration bus:

research thread
→ click around ChatGPT
→ referee thread
→ copy review
→ click back
→ continue research

Very sophisticated distributed systems architecture

But it works surprisingly well.

I also hit some Windows/native Computer Use issues while doing this and wrote one up in openai/codex#43373.

Someone suggested initializing the native Computer Use session with GPT-5.5 first and then switching models. I tested it and, at least for me, that worked: 5.5 initialized the session and Astra could then reuse the same live session.

Anyway, I think the direction is more interesting than “multi-agent”.

Something like:

Can ChatGPT be the OS for a tiny research organization?

You define the constitution, so to speak:

• what counts as evidence;

• when independent reproduction is required;

• what a reviewer is allowed to block;

• when something can be frozen;

• when stronger models should be used;

• what kinds of decisions still require a human.

Then the research director handles most of the day-to-day routing.

I’m curious if anyone else is doing this kind of thing.

Especially interested in systems where the orchestrator itself decides when to escalate, reproduce, research, or seek external review rather than following a fixed DAG/workflow.

If people are interested I can also post the Astra orchestration prompt, the referee protocol, checkpoint format, and some actual failure/review traces.