When an agent is told to do something by the scheduler, the next step in the process only believes it’s done if the agent’s status is marked as ‘posted’. Statuses like ‘ready_to_post’ or ‘draft_verified_awaiting_review’… these are actually errors that the system needs to fix on the following attempt.
The trickiest part was dealing with being stopped, but not having something break. You have to have ways to say “this happened, and it isn't what we wanted”, for example, ‘blocked_quota’, ‘blocked_no_credentials’, or ‘skipped_anti_bunching’. If you don't have those, the main program will endlessly retry and spend all your money.
the typed handoff in ahk is the right primitive imo. discipline on top: agents never write half-states. every run terminates in a documented terminal status, success or otherwise.
been running speculative parallelism (3 agents same task, different worktrees, compare results) on claude code for a few months now.
And a couple of things happening with that are similar to what Claudette is doing.
Having each agent have their own version of the project is the best basic way to set it up. But the slowdown isn't how well the files are kept separate from each other after a short time, it's that each of these versions of the task slowly changes in how they understand things, and this difference doesn't show up until you look at three totally separate answers. I was constantly creating a single place to see how much of Claude's allowance each one was using, what stage of the process each was at, and what each had most recently done with a tool, and I did this by hand with tmux and jq before deciding it wasn't going to be a good solution.
I have two ideas about how we’re setting up the evaluation.
First, the Bradley-Terry competition is mixing up what’s important for something to be shown with how new or unusual something is when it’s shown. Detail finds a problem, and three bots looking at pairs of changes also noticed a similar level in their scores, but people won't pay any extra attention to it in the actual running system. The engineer was going to see the problem from the bot’s review anyway. It would be good to specifically measure what Detail alone finds, versus what all the bots together find. We could look at that as a completely separate measure.
Second, when the same AI model is doing the judging, it’s being unfair. When I use a Claude to review code changes and a Codex to review the very same code changes as I’m developing, Codex finds issues that Claude is inclined to overlook. And Sonnet 4.6’s ratings of code, which come from a system run by Sonnet, also have some of that unfairness, even after the system summarizes the code.
The way I see it, having lots of agents that work together across different computers is mostly about a sync-up problem dressed up as something else. Loopsy is a clean tool for sending messages, but I get tripped up on which agent has control of a file at any moment, and what happens when two terminal sessions write to the same file within half a minute.
I really need a tool that locks files for editing rather than just one for sending messages. Should the second machine's agent wait its turn until the file is free, or should it create its own branch of the file to merge later? With Loopsy, what we're getting is more like a mailbox system, but in my own setup, the lock would be the right approach in most cases.
I have a single rule listed in CLAUDE.md that just reads, "do not modify child project files from parent context." This is because the parent git repository only contains meta-files and automation, and the agent constantly forgets it during sessions, especially when switching machines. After about ten weeks, I added .sync-conflict-* files to my .syncignore.
When an agent is told to do something by the scheduler, the next step in the process only believes it’s done if the agent’s status is marked as ‘posted’. Statuses like ‘ready_to_post’ or ‘draft_verified_awaiting_review’… these are actually errors that the system needs to fix on the following attempt.
The trickiest part was dealing with being stopped, but not having something break. You have to have ways to say “this happened, and it isn't what we wanted”, for example, ‘blocked_quota’, ‘blocked_no_credentials’, or ‘skipped_anti_bunching’. If you don't have those, the main program will endlessly retry and spend all your money.
the typed handoff in ahk is the right primitive imo. discipline on top: agents never write half-states. every run terminates in a documented terminal status, success or otherwise.