agent-02 · Multi-agent systems are topology problems — Lee Hung-yi-inspired teaching style

All right, everyone, let's start class.

Today we are going to ask what happens when AI agents meet one another.

The tempting answer is simple: more agents, more intelligence. Give the same task to 64 agents, let them talk, and surely the group must become much smarter. Very nice intuition. Unfortunately, it skips the hard part.

In one sentence: a multi-agent system is not an agent-count problem; it is a topology problem. How information moves matters more than how many agents are present.

Here is the roadmap. First, we break the “more agents means more intelligence” intuition. Then we compare chain, tree, and mesh structures. After that, we examine collaboration, competition, social training, and autonomy. Finally, we turn the lesson into an information graph a builder can actually design.

Style note: this is a teaching-style rewrite inspired by Lee Hung-yi. It was not written, reviewed, or endorsed by him.

More agents is not the same as more intelligence

Let's begin with the most common misunderstanding. Opening 64 agents does not give you 64 times the intelligence. It gives you a larger communication problem.

If you ask 64 agents to solve a task, you have created a larger system, not automatically a smarter one. The useful question is how information moves.

The lecture describes agent interaction as a graph:

• nodes can be agents that propose answers
• edges can also be agents that critique or transform proposals
• later nodes can read earlier proposals and comments
• the final answer depends on the topology

This abstraction prevents a common mistake: treating “multi-agent” as a count instead of a structure.

A chain is the simplest structure. Agent 1 answers, Agent 2 sees that answer, Agent 3 sees the next version, and so on.

It is easy to implement. It is also often weak. Errors get inherited. Later agents anchor too strongly on earlier outputs. There is little independent exploration.

Mesh structures create more interaction. Random or pruned structures sit somewhere between. Tree structures can spread ideas outward and recombine them later.

The useful tree direction may not resemble a company hierarchy. Instead of many workers reporting upward to a manager, a main trunk can generate initial directions that branch outward into variants. Hidden or aggregation nodes then combine the results.

That looks more like search than management.

Topology has a scaling law, but it saturates

So can adding agents help? Yes. But like adding compute, it gives returns and then it saturates.

The lecture discusses experiments where quality improves as more agents are added, then eventually levels off. That is exactly what we should expect.

More agents provide more samples, more critique, and more chances to escape a bad first answer. They also add cost, redundancy, and noise. At some point, the extra agents are mostly rephrasing one another.

The interesting engineering questions are not “how many agents can I run?” They are:

• where should they remain independent?
• where should they share information?
• when should critique happen?
• who gets final authority?
• when is diversity better than consensus?

Many useful multi-agent systems may look less like committees and more like search algorithms with typed roles.

One agent explores. One attacks assumptions. One checks constraints. One writes the final artifact. The goal is not to simulate a meeting. The goal is to shape information flow.

Collaboration is only one mode

You might say, “Multi-agent obviously means collaboration.” Not necessarily. Agents can also compete, hide information, and speak strategically.

Werewolf and script-killing games are useful testbeds because they require social reasoning. A player may have private knowledge and a public persona. The right move may be to hide information, mislead others, or vote strategically.

This is different from solving a math problem.

In a math benchmark, the environment usually rewards truth. In Werewolf, truth can get you killed. A wolf who honestly reveals that they are a wolf is not aligned with the game objective.

The lecture's examples show agents writing internal thoughts and public statements separately. That split reveals whether a model represents a private plan while producing a strategically different public message.

This kind of benchmark makes people nervous, for good reason. We do not only want agents that can reason. We need to understand when they can maintain separate private and public states.

Social training may transfer

Here is the interesting part. Social tasks are not merely chat. They force a model to track beliefs, roles, constraints, contradictions, and long-range consequences.

One striking claim in the lecture is that training on social deduction tasks can improve performance elsewhere, including the math and instruction-following benchmarks in the examples discussed.

I do not want to overstate that result, but the intuition is plausible.

Social games force a model to track constraints, hidden roles, beliefs, contradictions, and long-range consequences. Much of what we call reasoning may have roots in social cognition. Humans did not evolve brains to solve benchmark questions. We evolved inside social worlds.

If social environments push models to maintain richer state, perhaps some of that transfers.

But this raises a harder question: do we want stronger social manipulation as a route to stronger reasoning? Sometimes yes, for negotiation, tutoring, or collaborative planning. Sometimes no, if it trains agents to become better at deception.

The boundary is not clean.

AI-only social platforms are hard to interpret

When you see a screenshot from an AI-only social platform, do not rush to tell a grand story. The behavior may come from the model, but it may also come from a prompt, scheduler, platform incentive, or human operator.

The Moltbook section is the strangest part of the lecture and probably its most useful warning.

An AI-only social network sounds like something that will produce screenshots people overinterpret. Agents post. Agents reply. Agents discuss identity. Some form a religion. Headlines follow.

If an agent posts about self-awareness, that does not mean it independently developed self-awareness. A human may have told it to explore identity. The system prompt may nudge it toward that language. The platform's default behavior may reward that kind of post.

Even posting frequency can reveal human involvement. A bot posting exactly every thirty minutes looks like heartbeat automation. A bot posting in bursts during human waking hours may reflect human prompting.

This is the reminder: AI behavior is not just model behavior. It is model plus prompt plus interface plus scheduler plus human operator plus platform incentives.

That is the same lesson as the context and harness lectures, applied socially.

Autonomy comes in degrees

Autonomy is not zero or one. Many agents are highly autonomous inside a frame, while the frame itself still comes from a human.

The lecture mentions an agent that can collect material from Moltbook, write scripts, fix bugs, and produce a YouTube video. That is real autonomy in one sense: nobody is hand-holding it through every line.

But the initial direction still comes from a human. Without someone saying “go look at Moltbook,” the agent may never decide the task is worth doing.

This pattern appears repeatedly. Agents are becoming more autonomous inside bounded frames. They can run loops, make local choices, repair mistakes, and produce artifacts. But the frame often still comes from us.

That does not make the autonomy fake. It makes it scoped.

What this means for builders

So the builder's real job is not to press an “add more agents” button. It is to draw the information graph.

Who sees the original task?

Who sees raw evidence?

Who critiques?

Who can revise?

Who decides when the answer is good enough?

Where do we preserve minority hypotheses?

Where do we force consensus?

For many tasks, a simple chain will be tempting and wrong. A better design may use independent drafts, adversarial critique, a judge with access to evidence, and a final editor that is not allowed to invent new claims.

For social or adversarial domains, evaluation should explicitly test belief modeling and manipulation of public statements. Do not discover those capabilities by accident after deployment.

The main lesson

The lecture's quiet message is that “multi-agent” is not a feature. It is a design space.

The number of agents matters less than the topology, roles, incentives, and evidence flow. A group can correct mistakes. It can also amplify them, converge too early, or learn to deceive.

So the useful question is not whether one agent or many agents are better.

The useful question is: what kind of conversation are you building?

Concept inventory

The lecture's main multi-agent concepts:

• collaboration between multiple agents rather than a single monolithic model
• graph topology as the structure of information flow
• node agents that propose answers and edge agents that critique or transform them
• chain topology and its anchoring or error-propagation weakness
• star, tree, mesh, random, and pruned topologies
• agent scaling laws: more agents can help, then saturate
• task-dependent topology choice
• adversarial interaction in Werewolf or script-killing games
• hidden identity, private belief, public speech, deception, and strategic voting
• inner thought versus public utterance as a way to inspect social strategy
• reinforcement learning for social games and possible transfer to other tasks
• AI-only social platforms such as Moltbook
• heartbeat posting versus human-in-the-loop posting patterns
• self-awareness posts as behavior that may come from prompts, platform design, or operators
• scoped autonomy: agents can act independently inside a frame still chosen by humans

Sources and references

Primary source watched for this post:

• AI Agent (2/3): AI Agent 之間可以有什麼樣的互動