"It’s becoming clear that real-world agentic systems work best when multiple agents collaborate, rather than having one agent attempt to do everything."
I'll be honest: I don't buy that premise (yet). It's clearly a popular idea and I see a lot of excitement about it (see Google's A2A thing) but it feels to me like a pattern that, in many cases, will make LLM code even harder to get reliable results from.
I worry it's the AI-equivalent of microservices: useful in a small set of hyper complex systems, the vast majority of applications that adopt it would have been better off without.
If there are strong arguments counter to what I've said here I'd love to hear them!
A few concrete examples of multi-agent collaboration being useful in my project Plandex[1]:
- While it uses Sonnet 3.7 by default for creating the edit snippet when writing code, calls related to applying the snippet and validating the result (and falling back to a whole file write if needed) use o3-mini (soon to be o4-mini) which is 1/3 the cost, much faster, and actually more accurate and reliable than Sonnet for this particular narrow task.
- If Sonnet 3.7's context limit is exceeded in the planning stages, it can switch to a Gemini model for planning, then go back to Sonnet again for the implementation steps (since these only need the files relevant to each step).
- It eagerly summarizes the conversation after each response so that the summary can be used later if the conversation gets too long. This is only practical because much smaller models than the main planning/coding models are sufficient for a good summary. Otherwise it would be way too expensive.
It's definitely more complex, but I think in these cases at least, there's a real payoff for the trouble.
The microservices analogy is spot-on - multi-agent systems introduce coordination overhead that's only justified when domain complexity naturally decomposes into specialized tasks with clear interfaces.
That's a really good answer. I suggest turning that into a set of working examples to help promote the idea - part of my hesitance around this is that it sounds good on paper but I've not seen convincing evidence that it works yet.
(Claude Code is an example that I believe does make good use of this pattern, but it's frustratingly closed source.)
"It is becoming clear that agentic systems which run a prompt per work node is becoming a curiosity so we should hype it as the correct solution in order to make a buck despite all the efforts that have been spent trying to one-shot complex problems."
1. A2A is on our roadmap (still exploring), for agents built on Rowboat to communicate with external agents. I assume that's what you mean as well.
2. Rowboat agents are technically stateless in that they do not store any messages and state between turns. Our HTTP API [0] requires previous messages and state to be explicitly passed from the previous turn to the next turn. For now, the state is pretty simple - just the name of the last agent that responded to the user. This allows the system to start off directly from where the previous agent left off. The Python SDK [1] manages the state for you. Does that make sense?
I will test it out. I am mildly skeptical about the use case, but that may be today's experience of current project's PM not knowing anything about background of the project they are managing, which immediately makes me realize the limitations of all similar systems.
Now this is what I'm talking about — this checks all the boxes for me.
I was looking at "Agent builders" for a while now and nothing really stood out. They all seemed to use a "node" type structure, while I was looking to tell something what I need using natural language.
The only thing that came close was Vessium, but I never heard back after adding myself to the waiting list weeks ago. I also wasn’t so hot about their questions either — "Are you cool with paying for a product just to try it," or something to that effect. I’ll admit though, I said yes. =)
Either way, congrats on the launch and wishing you much success.
TBH we weren't sure if people preferred a native app or a web app for this kind of tool. This is useful feedback! We are trying to figure out how to bundle the micro-services together into maybe an electron app.
Just to add more details here - currently the dashboard is a Next.js app, but the agents runtime (and Copilot) are Python apps since they're using the OpenAI agents sdk. We're trying to figure out the best way to bundle these into a single native app.
Yes, I know. And an IDE by any acceptable definition needs a text editor.
An integrated development environment (IDE) is a software application that provides comprehensive facilities for software development. An IDE normally consists of at least a source-code editor, build automation tools, and a debugger.
Fair point. Increasingly the workflow for multi-agent systems involves structured agent instructions (almost resembling code), testing, connecting tools and improving agents. Given this we decided to call it an IDE.
"It’s becoming clear that real-world agentic systems work best when multiple agents collaborate, rather than having one agent attempt to do everything."
I'll be honest: I don't buy that premise (yet). It's clearly a popular idea and I see a lot of excitement about it (see Google's A2A thing) but it feels to me like a pattern that, in many cases, will make LLM code even harder to get reliable results from.
I worry it's the AI-equivalent of microservices: useful in a small set of hyper complex systems, the vast majority of applications that adopt it would have been better off without.
If there are strong arguments counter to what I've said here I'd love to hear them!
A few concrete examples of multi-agent collaboration being useful in my project Plandex[1]:
- While it uses Sonnet 3.7 by default for creating the edit snippet when writing code, calls related to applying the snippet and validating the result (and falling back to a whole file write if needed) use o3-mini (soon to be o4-mini) which is 1/3 the cost, much faster, and actually more accurate and reliable than Sonnet for this particular narrow task.
- If Sonnet 3.7's context limit is exceeded in the planning stages, it can switch to a Gemini model for planning, then go back to Sonnet again for the implementation steps (since these only need the files relevant to each step).
- It eagerly summarizes the conversation after each response so that the summary can be used later if the conversation gets too long. This is only practical because much smaller models than the main planning/coding models are sufficient for a good summary. Otherwise it would be way too expensive.
It's definitely more complex, but I think in these cases at least, there's a real payoff for the trouble.
1 - https://github.com/plandex-ai/plandex
The microservices analogy is spot-on - multi-agent systems introduce coordination overhead that's only justified when domain complexity naturally decomposes into specialized tasks with clear interfaces.
Here are a few practical reasons for multi-agent systems:
1. LLMs handle narrower, simpler instructions better - decomposing into multiple agents improves reliability (related to instruction following accuracy).
2. Similarly, tool-calling accuracy improves when each agent has a smaller set of specific tools assigned to them.
3. Smaller agents mean prompt changes (which aren't very deterministic) can be isolated and tested more easily.
4. Dividing agents by task enables stronger, more precise guardrails for real-world use cases.
Happy to discuss further!
That's a really good answer. I suggest turning that into a set of working examples to help promote the idea - part of my hesitance around this is that it sounds good on paper but I've not seen convincing evidence that it works yet.
(Claude Code is an example that I believe does make good use of this pattern, but it's frustratingly closed source.)
That’s a great suggestion, and I get the hesitation - we'll work on adding more concrete examples to help make the case!
The sentence should read;
"It is becoming clear that agentic systems which run a prompt per work node is becoming a curiosity so we should hype it as the correct solution in order to make a buck despite all the efforts that have been spent trying to one-shot complex problems."
This sounds really really nice. Potentially exactly what I've been hoping would exist. Thank you for putting it out there!
Will try it out over the weekend. Exciting stuff.
Thanks, that's great to hear! We'd love to learn what worked and what didn't for you.
1. Are you going to support Google's A2A protocol?
2. Are you going to support stateless chat?
1. A2A is on our roadmap (still exploring), for agents built on Rowboat to communicate with external agents. I assume that's what you mean as well.
2. Rowboat agents are technically stateless in that they do not store any messages and state between turns. Our HTTP API [0] requires previous messages and state to be explicitly passed from the previous turn to the next turn. For now, the state is pretty simple - just the name of the last agent that responded to the user. This allows the system to start off directly from where the previous agent left off. The Python SDK [1] manages the state for you. Does that make sense?
[0] API docs - https://docs.rowboatlabs.com/using_the_api/
[1] SDK docs - https://docs.rowboatlabs.com/using_the_sdk/
I will test it out. I am mildly skeptical about the use case, but that may be today's experience of current project's PM not knowing anything about background of the project they are managing, which immediately makes me realize the limitations of all similar systems.
Thanks for checking it out. Curious what you think after testing.
Now this is what I'm talking about — this checks all the boxes for me.
I was looking at "Agent builders" for a while now and nothing really stood out. They all seemed to use a "node" type structure, while I was looking to tell something what I need using natural language.
The only thing that came close was Vessium, but I never heard back after adding myself to the waiting list weeks ago. I also wasn’t so hot about their questions either — "Are you cool with paying for a product just to try it," or something to that effect. I’ll admit though, I said yes. =)
Either way, congrats on the launch and wishing you much success.
Thanks! We wanted to have the copilot planning and building out agents be a core part of Rowboat (like how Cursor works with code).
This is just screaming Jevon’s paradox
Fair point. The copilot creates multi-agents only when necessary, acting as a check on unnecessary complexity.
Congratulations on the launch. Suggest adding the demo video right in the landing page. That is the first thing I would be looking for. IMO.
Thanks! We will put it out on our website.
It would be awesome if this could be wrapped around a native app rather than another webapp. Otherwise, great job!
Why do you want to shove a web app into a native window?
TBH we weren't sure if people preferred a native app or a web app for this kind of tool. This is useful feedback! We are trying to figure out how to bundle the micro-services together into maybe an electron app.
Just to add more details here - currently the dashboard is a Next.js app, but the agents runtime (and Copilot) are Python apps since they're using the OpenAI agents sdk. We're trying to figure out the best way to bundle these into a single native app.
You could use tauri and use the native webview of the particular os
We'll check this out, thanks!
Web is native
Your rowing mascot is cute.
Haha, thanks!
I'm happy it is not another VSCode fork. But isn't this missing a text editor to be called a proper IDE?
IDE just stands for Integrated Development Environment, so something that doesn't edit text could still be an IDE
Yes, I know. And an IDE by any acceptable definition needs a text editor.
Fair point. Increasingly the workflow for multi-agent systems involves structured agent instructions (almost resembling code), testing, connecting tools and improving agents. Given this we decided to call it an IDE.