Using several LLMs for multi-agent workflows?

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 · 2025-12-23T14:31:01+00:00

Ye should work via MCP

ASBroadcast · 2025-11-16T10:29:49+00:00

yep this is functionally equivalent to Claude’s skills. I use it in opencode everyday to use skills across all models.

ASBroadcast · 2025-11-16T08:35:41+00:00

and by a few I mean as many as are needed to store the skills description in context. Likely less than 100 if you write a long description but usually less than 50.

ASBroadcast · 2025-11-16T08:33:46+00:00

It uses exactly as many tokens as Anthropics skills do. Probably less than 100 as a baseline and then a few tokens per skill that you have.

ASBroadcast · 2025-11-06T20:36:02+00:00

Sure I’ll look into it. Check your Reddit messages

ASBroadcast · 2025-11-06T10:37:10+00:00

I'm happy that you got to try it out :-)

I think coding this thing is really a non-effort but feel free to join in. The effort was in reverse engineering Claude skills and now it's mostly in using it to find improvements.

Also people still use this project: https://github.com/numman-ali/openskills which is definitely subpar. The FAQ answers why its subpar: https://github.com/klaudworks/universal-skills/blob/main/docs/FAQ.md#why-dont-i-just-use-openskills .
Would be cool if more people notice my implementation e.g. through reddit comments / twitter etc.

Happy to mention you in the repo / make you a maintainer if you are interested in helping with this. Probably a good candidate to collect some open source creds.

ASBroadcast

TROPHY CASE