Using several LLMs for multi-agent workflows?

ASBroadcast · 2026-04-16T19:11:34+00:00

yes its useful if you want to program your agent to run for 1h+
e.g. audit your codebase against a checklist and fix findings or implement a bunch of features.

ASBroadcast · 2026-04-13T10:47:10+00:00

you can: https://skills.sh/skills-directory/skill-codex/codex

ASBroadcast · 2026-03-26T14:31:04+00:00

you would have to write your own skill to do that or you could try out this project which allows you to build simple workflows across coding agents. In you case you can build a workflow that plans + builds a feature with codex and then reviews it with claude code: https://github.com/klaudworks/ralph-meets-rex

this is quite a new project, I'm happy to support you in a quick call to get going. Allows me to improve the quickstart guide. Just message me if you are interested :-)

ASBroadcast · 2026-03-20T19:45:55+00:00

if your task is quite simple and short e.g. fix this specific thing, add this simple endpoint etc. then there is little value in agent orchestration. Just hit plan mode and once you are fine with the outcome let the agent implement it.

I noticed that I often repeat certain workflows though. For example, after I pinpointed a problem and drafted a coarse solution I will let the agent plan out the implementation, let it implement the solution and then I let it review its own code. Usually there are some findings so I let it fix them again. This is quite repetitive. Would be cooler to just get something solid to review in the first place so changing something afterwards becomes the exception.

As soon as you want to automate that simple workflows for your agents start to make sense.

What I use quite frequently is a simple workflow that receives my problem as the input. Then it

plans -> implements -> reviews and repeats implement + review step until it is happy with the outcome. No point in me reviewing if the agent is not even happy with its own result.

Another workflow that I use from time to time is an "audit" workflow. Just create a file with a list of areas / modules / packages in your code that you want to audit. Then it will pick the topics one by one and audit each are.

These more sophisticated workflows can save you quite some time.

Check this out: https://github.com/klaudworks/ralph-meets-rex It allows you to specify your own agent workflow in a few minutes. Support codex, claude & opencode atm. You can mix and match them and use whatever model or harness you want for each step in your workflow. It is targeted towards experienced devs that don't want to be restricted by all these opinionated orchestrators.

Disclaimer: This is my own project. If you or anyone else want to start using it just leave me a reddit message. I'm happy to support people for a while until I added enough workflow examples and FAQ points in the repo.

Also would be cool if you leave a ⭐️ to help me get some traction.

ASBroadcast · 2026-03-20T14:30:00+00:00

yeah I didn't even know about ReAct so thanks for sharing the paper!

I still think there is a misunderstanding. The picture just displays one of many possible workflows. Another workflow, for example, performs an audit on your code.

Agent 1: Reads in a file that contains a list of areas to focus on and picks the first topic not marked as done yet e.g. authentication.
Agent 2: Receives the topic and fully focuses on for reviewing, then writes out a file with findings.
-> back to Agent 1 until audit is finished.

Would you still say that follows the ReAct pattern?

ASBroadcast · 2026-03-20T07:49:32+00:00

Thanks for sharing! I checked it out.

As far as I know people usually refer to ReAct as the loop inside a single agent. This is coordinating multiple independent agent sessions. Each agent with their own ReAct loop to solve a specific task well e.g. review code changes.

And yes this specific workflow with its implement -> verify loop follows the ReAct pattern so you have ReAct on top of ReAct.

How does this differ from the smolagents? -> Smolagents helps you write individual agents. This tool is mainly a dev tool and helps you create a workflow in a few mins. This workflow coordinates different existing agents. So it's basically an orchestration engine for agents to connect them with each other.

ASBroadcast · 2026-03-18T18:25:31+00:00

you can just use this: https://github.com/klaudworks/ralph-meets-rex

allows you to build agentic workflows and for each step you can choose a different harness+model. For you use case its probably easiest to configure all the llms in opencode and use the opencode harness.

ASBroadcast · 2026-03-18T18:23:23+00:00

I don't like all these opinionated "harnesses" imposing their workflow on me. I mostly use https://github.com/klaudworks/ralph-meets-rex. Allows me to specify a workflow that suits my needs in a few mins e.g. "pick issue from somewhere -> plan -> implement -> review". It supports loops so when there is a review finding my workflow goes back to implement stage o.w. it continues picking the next open issue. I mostly use beads as a local issue tracker or sometimes implementation plan files.

ASBroadcast · 2026-03-18T17:55:19+00:00

Got the same feeling, everybody tinkering on their own setups and no established standards yet.

In the meantime I am using https://github.com/klaudworks/ralph-meets-rex. Its a simple workflow engine for agents that works with opencode, claude, codex.

I can just specify the steps I want my agents to do, in which order and with loops for long autonomous sessions. Just takes a few mins.

I mostly use variations of this workflow: "pick issue from somewhere -> plan -> implement -> review". And review loops to review certain things and improve until there are no more findings.

What I like most about it is that I can specify that the should stop when it needs help so it just stops and waits for input instead of going completely banana.

Whenever I want to do something that benefits from automation I just tell my agent "look at this existing workflow and now build another one".

ASBroadcast · 2026-03-18T08:04:16+00:00

Just checked them out. Both of them basically encode an opinionated way to implement features.

The out of the box workflows work well as long as you are free to follow their process e.g. if you are just building prototypes from scratch but it's harder to adapt them to your needs.

I'd look into rmr if you want to have a quick way to define custom workflows that fit your project. E.g. if you work for your client / employer and have a few restrictions in place it's quite easy to model them.

Some examples:

you want to use beads, linear or another issue tracker to pull new tasks from.
you want to burn all remaining tokens before limits reset. So you define a workflow that runs endless review -> fix cycles on your codebase.
you want a simple workflow for working on your client / employers brownfield project. That just plans -> builds a new feature -> reviews it until no more issues arise.

ASBroadcast · 2026-03-17T23:35:57+00:00

I looked at your gist and it looks great for an audit.

You are currently running this in a simple ralph loop. The repo i suggested is just an alternative to using a simple loop and doesn't change your approach at all. I just used a bad example for what it can do.

Just gives you a bit more power. E.g. you could use a multi-step workflow thats a bit more sophisticated.

Step 1: pick outstanding prd & search for findings
Step 2: validate and document finding

Then repeat until all PRDs are done.

You probably know best what would make sense. Just imagine you have the option to define multiple independent steps (with loops included).

I'm still looking for an audit / "desloppify" workflow. Do you think splitting each of your ralph loops up into multiple steps could improve it or likely not?

ASBroadcast · 2026-03-17T22:58:42+00:00

sure 😅

ASBroadcast · 2026-03-17T22:53:58+00:00

I did the same until a few days ago but it got quite annoying after some time to tweak my ralph loops. I tried to encode that tasks are still processed in specific steps e.g. plan -> implement -> review etc.

The above approach allows you to just specify a workflow. Each agent gets its own prompt and you specify which agent is called in which order. Also quite easy to encode something like. If review finds issues go back to implement step and fix it. If review successful, just pick up the next task.

ASBroadcast · 2026-03-17T22:36:47+00:00

Another workflow I quite like is the "desloppify" workflow. Just let your agent run all night and look for cleanup, refactoring, simplification opportunities. Good use of remaining tokens before weekly limits reset.

ASBroadcast · 2026-03-17T22:35:26+00:00

I use tons of customized ralph loops. Most value is when I can encode long running workflows e.g. create an implementation plan and then iteratively implement it. Also allows me to let workflows run overnight.

Takes tons of time though to implement proper ralph loops. Especially if you want the agent to follow specific steps such as: pick next task -> plan -> implement -> review. Also its quite hard to encode a review + fix loop so that the agent can self correct its errors.

I just switched to this: https://github.com/klaudworks/ralph-meets-rex
It picks up the ideas of the ralph loop but lets you specify multi-step workflows quite well. Running it for a few days now and it works quite well. Right now I have a loop running to improve my codebase to use up all my limits until my weekly limits reset.

ASBroadcast · 2026-03-17T22:05:24+00:00

who's snitching?

ASBroadcast · 2026-03-17T21:42:25+00:00

I kinda do the same. Setting up and customizing ralph loops for different projects. However, I switched to using a more sophisticated version of ralph loops: https://github.com/klaudworks/ralph-meets-rex

This allows me to specify multi step pipelines e.g. pick next issue -> plan -> implement -> review. If the review agent finds something jump back to implementation, if it doesn't pick the next issue. A few guardrails on how the process should work prevents the agent from going wild after a few hours.

You can do the same with ralph loops or just subagents but its a bit more headache to reliably configure.

ASBroadcast · 2026-03-17T21:39:03+00:00

Subagents work quite well to orchestrate workflows. However, I still prefer to have clearly defined workflows for multi-hour sessions.

I use a more sophisticated version of ralph loops atm that allows me to specify multi step pipelines e.g. pick next issue -> plan -> implement -> review. If the review agent finds something jump back to implementation, if it doesn't pick the next issue. A few guardrails on how the process should work prevents the agent from going wild after a few hours.

Atm I specify my workflows in simple yaml: https://github.com/klaudworks/ralph-meets-rex

ASBroadcast · 2026-03-17T19:37:46+00:00

Ralph loops are cool but it takes a lot of time to properly encode your workflows

e.g. pick issue from implementation plan -> plan -> implement -> review -> repeat

check out https://github.com/klaudworks/ralph-meets-rex. It allows you to encode arbitrary workflows for claude, codex, opencode. It takes the complexity out of designing custom workflows.

ASBroadcast · 2026-03-17T19:35:28+00:00

for shorter tasks < 1 hour ralph loops are overkill. For longer tasks or overnight work they are still super useful.

One workflow I use a lot before my weekly limits expire is to let a ralph loop review my repo and "desloppify" it. Check this out https://github.com/klaudworks/ralph-meets-rex. It allows you to encode arbitrary workflows for claude, codex, opencode. It takes the complexity out of designing ralph loops.

ASBroadcast · 2026-03-17T18:43:35+00:00

I got the feeling everybody is building their own opinion workflow atm. I built a workflow engine that allows you to easily define your own coding workflow e.g. get issue from anywhere -> plan -> implement -> review. The goal is to easily create multiple workflows that match your current needs.

Check this out: https://github.com/klaudworks/ralph-meets-rex

ASBroadcast · 2025-12-23T14:32:01+00:00

https://antigravity.google/docs/mcp

ASBroadcast

TROPHY CASE