The Multi-Agent Tooling Explosion — Rowboat, Agno, and What It Means

June 1, 2026 · 7 min read

A few months ago, building multi-agent systems meant stringing together Python scripts, shell commands, and hope. The tooling barely existed. If you wanted two LLMs to talk to each other, you wrote the orchestration layer yourself.

That’s changing fast. In the last week alone, three multi-agent tools hit the front page of Hacker News: Rowboat (161 points), Agno (76 points), and NovaStelo (90 points). Each one takes a different approach, but collectively they signal something important — multi-agent orchestration is becoming a platform play.

Why Multi-Agent Matters

Let me be clear: a single agent can do a lot. My pipeline uses one Coder agent that handles bug fixes end-to-end with 9 specialized skills. But a single agent has hard limits:

Context saturation: One agent doing everything fills its context window fast. It forgets the bug report by the time it’s writing the PR.
No self-correction: A single agent can’t review its own output effectively. It’s too close to the work.
Cost inefficiency: Running a powerful model for every subtask is wasteful. A cheap model can run tests while an expensive one builds features.

That’s why my pipeline uses four agents: Supervisor, Coder, Reviewer, QC. Each has one job, one model tier, one budget limit. They don’t share context — they share artifacts (PRs, test results, verdicts).

The Three Approaches

Rowboat — The IDE for Multi-Agent

Rowboat calls itself “an open-source IDE for multi-agent systems” and it earned 161 points for a reason. It gives you a visual interface to design agent workflows — think of it like Node-RED but for LLM agents. You drag boxes (agents), connect them with arrows (message passing), and the system handles routing, retries, and state management.

What I like: the visual debugging. You can watch messages flow between agents in real time, see costs accumulate per agent, and replay failed runs. That’s huge for debugging complex agent chains.

The downside: it’s a desktop app. For my cron-based pipeline, I need something that runs headless on a server. But for prototyping multi-agent architectures, it’s probably the fastest way to iterate.

Agno — Framework for Builders

Agno is a full-stack Python framework for building multi-agent systems. It handles the things you’d otherwise build yourself: agent memory, tool registration, message routing, and logging. You define agents as Python objects with tools and model preferences, then compose them into teams.

This is closer to what I use today. My pipeline is essentially a manual version of what Agno does — route issues, spawn agents, collect results. If I were building from scratch today, I’d start with a framework like Agno rather than wiring it all myself.

NovaStelo — Making It Visual

NovaStelo takes a different angle: block-style programming for multi-agent systems, inspired by MIT Scratch. It’s designed for education and rapid prototyping. Drag and drop agent behaviors, connect them visually, run the whole thing in a browser.

I won’t use this for production pipelines, but I’d recommend it to anyone who wants to understand how multi-agent systems work without writing infrastructure code first.

What I’m Actually Using Today

Here’s the honest take: I’m still running my hand-rolled pipeline. It works, it’s predictable, and I know every line. But I’m watching these tools closely because they solve real pain points:

Message routing between agents (I wrote this in 50 lines of Python)
Agent state persistence (I use JSON files)
Cost tracking per agent (I have a CSV logger)
Failure escalation (a long if-else chain)

The question is: when does a framework become worth the switch? For me, it’s when my pipeline needs more than four agents. If I add a testing agent, a documentation agent, and a deployment agent, the manual wiring becomes a maintenance burden. At that point, a framework like Agno starts to make sense.

The Pattern That Works

Regardless of tooling, the architecture that works is the same:

One agent, one job. Don’t give an agent multiple responsibilities. A reviewer that also writes code will be biased toward accepting its own output.
Separation of context. Agents shouldn’t share their full conversation history. Pass artifacts, not context windows.
Independent budgets. Each agent gets its own turn limit and cost cap. One runaway agent shouldn’t drain the whole pipeline’s budget.
Human gate at the end. No matter how many agents you chain together, a human should approve the final output before it reaches production.

The Bottom Line

Multi-agent tooling is where static site generators were in 2015 — everyone’s building one, they’re all slightly different, and nobody knows which approach will win. That’s fine. The principles matter more than the tools.

Rowboat is great for visual prototyping. Agno is solid for production Python pipelines. NovaStelo is perfect for learning. Pick the one that matches your skill level and deployment environment.

Or do what I did: start with a shell script and four Claude sessions. You’ll learn more about the architecture in a weekend than you will reading documentation for a month.

Follow me on X for more on multi-agent architectures and autonomous development pipelines. All posts at susiloharjo.web.id.

Discover more from Susiloharjo

Subscribe to get the latest posts sent to your email.