How I got Astra past the plateau

First, I tried letting a long run be a long run.

The obvious starting point was the kind of long-running work I had already been doing: give the agent a substantial request and let it continue. I also tried the repeated improvement loops and gauntlet loops I used with Claude. Astra could make a strong start, but it could still get absorbed in a small part of the project.

The lesson was that persistence and direction are separate problems. Keeping a model working does not, by itself, tell it which part of a large ambition matters next.

Then I tried giving the work more structure.

I experimented with splitting the work into lanes and giving agents more specialized roles.

A clearer division of labor helped organize the work. But coordination and approval could become their own bottlenecks. I would not rule out the setup simply because my version ran into limits; I may not have been using it in the best possible way.

What I carried forward was the value of distinct responsibilities. What I still needed was a way for the overall plan to keep advancing without creating additional bottlenecks.

Eric Provencher was an influence on this approach. He’s now at OpenAI.

I also tried having a supervisor stand back.

Another approach gave an agent a more supervisory job: check in periodically, ask for evidence, and keep some distance from the implementation. My initial version checked in every 30 minutes.

I expected this one to work very well, but unfortunately it didn’t make much of an improvement at all.

Changing the organization was another experiment.

I tried giving the coordinator more freedom to change the roles and team structure as problems appeared. Instead of treating the initial organization as fixed, it could adjust how the work was divided.

That was an interesting capability, but it did not settle the larger problem for these projects. A different arrangement of agents could still run into the same plateau.

Then I went back to a checklist.

This is actually one of the oldest tricks in the book when it comes to working with agents on longer tasks, but it’s gone somewhat out of fashion recently as agents can do a lot of this on their own. I figured it might help to extend this model into seriously long-horizon tasks.

I had the agent break the goal into a checklist with phases. It would implement one phase in goal mode. When it finished, I told it to move to the next one. Usually that just meant saying, “Keep going.”

So I automated the part I was doing.

I quickly realized that I was the bottleneck in this loop. I had to approve it every time or I had to tell it to move forward every time. All I was saying was, ‘Keep going,’ so I automated that part too. It turned into this loop that’s working really, really well.

The coordinator interviews me, agrees on the goal, and turns it into a checklist and phases. The implementer runs in a separate Codex session. It is not the coordinator’s sub-agent, although it can bring in sub-agents of its own.

The coordinator gives the implementer a phase to complete and keeps the larger plan moving. The implementer works on that phase, checks the result, and reports back. Goal mode is part of the setup I used to keep it working toward the current finish line.

That division is the useful idea. One session stays responsible for direction across the project; the other stays responsible for the work in front of it.

What I want to improve next.

I also still want long-running autonomous work to happen more naturally. Astra can get absorbed in details.

What changed for me is that I found an arrangement that could keep these larger projects moving with much less steering from me. The next useful step is to make it easier to reproduce, test where it breaks, and keep the parts that actually help.