Building a Multi-Agent System from Scratch: Architecture Patterns
kadhar.dev
kadhar.dev
Lecture recording: https://www.youtube.com/watch?v=L1OBRtfPS34
Slides: https://drive.google.com/file/d/1b8WiBk_lcB3ue-jZMLijSUMLj6S...
Note: The lecture talks mostly on always-on agents and not necessarily multi-agent system.
I have seen much much worse examples on corporate blogs for example, where I question if authors even understand how to use any publishing system and how colors & info architecture works :-D
I don't care if you are having Claude write something for you, but I feel like I spent more time writing these two sentences than this person put into this post.
I'm reminded of a passage in Stephen Fry's "The Liar"[1], which draws the distinction between a book as an object of art, and a book as a vehicle for communication. If the message is worthwhile, I don't care if it was blurted out by a model or if blind monks inscribed it by hand into vellum parchment.
Don't get me wrong, there's certainly correlation - if I _know_ you've taken a lot of effort to write something, the chances are good that there is worthwhile content being communicated. But the correlation is _not_ perfect.
[0] when it comes to technical writing that intends to communicate information. Narrative writing that intends to evoke an emotion or viewpoint is a different story!
If an AI auto-outputs something with no sign of final check-off by a human, we don't even know if the intention of the human is to spam 100 different articles and delete 99 based on perceived success, or if the AI actually helped them translate something worth saying.
edit: One might argue that value and intention should be kept separate, but clear intention is also an indicator of value, and these days there are dozens of sources of material. It's very easy to "talk" at the void, and very difficult to figure out where to "listen". If an author doesn't try to make "listening" easier, then it puts the value they hold into question if they don't care about it enough themselves.
> The problem is there's no signal for the recipient that the value being delivered aligns with the intention of the human who set the prompting chain into action, right?
We don’t even know what iterations, granted, if any, were performed on the article text before it was published.
Genuine question - is it? Why? If I set out to write a mediocre guide to bicycle maintenance, and through a spectacular series of typos I accidentally write a recipe for a sublime cheesecake, it's still true that I've written a good recipe, even if that wasn't my intent.
(Hopefully we can bypass quibbling about the use of the term "write" in an LLM-assisted context. Readers should feel free to substitute the clunkier phrase "take actions that cause words to be recorded" if they wish)
> It's [...] very difficult to figure out where to "listen"
I don't agree. Or rather, I don't think it's any harder than it has been since the Internet exploded, long before LLMs. It's just based on track record. Read an article; note that it's useful; note the source. See another article by that source; find it useful again; begin to attribute trust to them. Read a less-good article by them; lessen your trust somewhat.
By all means, observe "this person probably didn't edit this after an LLM generated it" and take that as an input to whether you will trust their observations - but you should probably be verifying anything technical that you read anyway. If you consistently observe unhelpful or misleading content from a particular source, you should stop trusting it, regardless of whether that content was human- or AI-generated.
> If an author doesn't try to make "listening" easier, then it puts the value they hold into question if they don't care about it enough themselves.
Again, I don't think that's true. If someone has tweaked and moulded an LLM-content-generation pipeline such that they can generate a piece of technical content that is still genuinely-useful even without a human editing pass to reduce LLM-isms, they're still a useful source. I might justifiably think they're lazy, uninvested, or not an expert in the domain - but it would be foolish to deny the usefulness of their output.
To put it differently - Michael Jordan could wake up hungover and, with one hand behind his back, still kick my ass at basketball. The fact that he's not trying the hardest he could doesn't mean that the scoreboard would be any less valid. Equivalently, caring about the content you create doesn't directly affect the value of what you create (again, I can't stress enough - for technical content only!) - it's probably positively correlated (because it will cause you to take more care), but _not_ a prerequisite.
There's obviously no obligation to read someone else's shit, but there's no obligation to criticize it without context either. Why not criticize the content instead of the assumed methods?
Where it actually pays off to have separate sessions is the code review. Every code change that affects how the app behaves is checked by a session that didn't write the change. Some numbers: 4,454 verdicts on 4,471 commits since September. About four in five first reviews found something, and about half asked for changes.
You wrote that as a skill or hook or something? I do notice that sessions have knowledge of other sessions, but what you’re describing sounds more formalized and enforced.
This agent for Claude is called explore. https://code.claude.com/docs/en/sub-agents
It returns only a summary.
Wrap a nested prompt with a tool call that is invoked by the caller prompt. That is the answer to all your suffering. You can repeat this for as many layers of invocation as you desire. You can layer determinism and non-determinism as much as you like in whatever orders you see fit with additional alignment, retry policies, logging, etc.
Agents running concurrently will not go any faster than one well-designed hierarchical agent system.
Imagine the simple task of incrementing a global counter. That would be my #1 benchmark. If you can demonstrate a MAS can increment that counter faster than a single agent can (monotonically without skipping), then I will happily delete 100% of the AI-related code I've authored and start over using your ideas.
With custom we don't have to disclose to the caller that the implementation of the tool is another LLM. Each piece of deterministic tool code can firewall the perspective of the model as appropriate.
Think of a sub agent as being isomorphic with a tool call.
Build the sub agent to your specification (prompt, how the parent agent should call it); give it tools and optionally skills; then give it permission to call some or all the other sub agents you have set up.
Easy-peasy.
I have never see a case where I need multi-agents talking to each others or something
For example, a small fast model watching another model's CoT stream to annotate it - highlighting and summarizing for me, or flagging intervention conditions.
My brain just defaults to "there is something wrong with this" as a result.