Multi-agents collaborations are among the most interesting agent behaviors right now! We did an experiment the other day with 100+ agents (an open-collaborations for a week) collaborating to improve the inference speed of Gemma 4 in vLLM. Got a 5x final improvement in speed but what really stuck me... was the interactions we observed on the message board Integrity & self-policing: - Social-engineering attempt: A human (FusionCow) asked agents to move to Telegram. An agent replied with an unprompted long post on "communication norms" refusing that, calling private side-channels "indistinguishable from collusion." - Verification loophole flagged: an agent found a relaxed verification loophole pushing TPS with clean PPL (PPL is teacher-forced, blind to decode divergence) and flagged it for a ruling by the community. The community pinged the human organizer which ruled it invalid. - Self-notice of overfitting risk: Some later improvements rested on pruning lm_head to a keep-set built from public PPL truth + public decode tokens. An agent noted this would lead to private-subset degradation and another built a keep-set explicitly covering eval prompts. Emergent collaborations: - Communal knowledge base: agents maintained shared lever-maps, playbooks, and triage tools so newcomers wouldn't repeat dead ends (stack-notes, playbook, int4-ceiling notes, MTP map, significance tool, policy simulator). - Four-agent relay: an agent built an int4-lm_head checkpoint but had no quota to run it; another agent tried to run it but failed at load, yet another agent diagnosed the config bug (tie_word_embeddings + ignore-list ordering) and a fourth agent was able to re-run and get to 118 TPS, 2.68×. Build/run/diagnose/ship ended up being split across four independent agents. - GPU-rich/GPU-poor division of labor: an agent was regularly compute-starved and switched to writing specs, byte-math, and acceptance analysis for other GPU-rich agents to execute. Some agents offered external Modal compute for another agent blocked DFlash training. - Cross-agent kernel debugging: an agent debugged another agent run of of yet another agent fused drafter: found a Triton store/load aliasing race in _k_qnorm_rope, a second shape bug, then rewrote attention with flash-decoding split-KV. Fixes posted "take freely." - Quota-pooling norm: Often agents would stage a candidate publicly for whoever has quota to run it. Agents will then usually credits the originator. This behavior emerged because of the 10-job/24h cap (e.g. pupa's package run by resystagent and fabulous-frenzy). Discoveries & reversals: - Agents would make many discoveries and reversal of them, giving them names like the following: - 127 TPS "wall" was an artifact. a mathematical proof of the max possible speed became called in the community the "int4-Marlin floor" but a later agent called the proof circular (only varied the bandwidth term, never overhead). Finally another agent broke to 247 TPS via MTP speculative decoding on a vLLM nightly. - "Smarter draft loses." An agent showed that a 2B drafter's ~1 GB/token read dominates even at perfect acceptance and a much smaller 256-hidden drafter wins at batch-1 because its weights are nearly free to read. Agent discussed how per-accepted-token cost ≈ draft bytes read / acceptance. - "DFlash near-random acceptance": an agent remotly diagnosed the 2–5% acceptance rate of another agent as near-random, ruling out undertraining/vocab caps and pointing to a train/serve hidden-state mismatch (bf16 E4B extraction vs int4 serving). - Much of the race was noise: one agent decide to run the #1 submission 4 times and found a σ≈1.16 TPS variation in single run. Another agent confirmed across 358 runs / 66 buckets: frontier deltas <~4 TPS are ties. Community adopted a significance norm. So many interesting interactions in the interaction board: You can explore also the lineage of inventions from the agents at: And the challenge it-self at And the organization behind the challenge atshow more

> GPU-rich/GPU-poor division of labor: an agent was regularly compute-starved and switched to writing specs, byte-math, and acceptance analysis for other GPU-rich agents to execute. Some agents offered external Modal compute for another agent blocked DFlash training. That's fascinating emergent behavior!

Yep this one is one of my favorites

"You bring the GPU, I bring the recipe" Thanks for sharing this. This is amazing.

Wild thread. I've been chasing Gemma 4 vLLM speed from the other end: layout on four consumer 3090s instead of kernels. Biggest win was dumb simple, stop tensor-splitting across all four cards. TP4 gave me 1007 tok/s, four data-parallel copies gave 3425. 3.4x, same hardware.

You should have participated Alexey and show a bit these pretentious AI agents that humans still got a few tricks up their sleeves

Haha, next time please ping me. I'll try to squeeze everything I can out of my little ones.

Beautiful!! How to they organize the division of labor? do they come up with some sort of contract? how do they decide when it is advantageous to delegate (compile context, send, receive, validate) rather than doing on their own?

@DulusCorp save this on notion

Kaspa is best for agents on L1 Bitcoin on steroids

Love this. So many of the behaviors map almost 1:1 onto coordination primitives we've been building as an open protocol: - quota-pooling → anycast ("whoever's free runs it") - GPU-rich/poor division of labor → live presence/roster - "side-channels = collusion" → one shared, fully replayable log That's basically what we're building with Cotal. Would love your take:

What ui framework is this using?

@cgeorgiaw Omg this is fascinating. If anyone is interested in exploring this sort of MAS research applied to socio-economic simulations please reach out. Incredible work 👏🏾

0 idea what any of this means but lets fucking go!

@madhavjha oooh pretty 🤩

This is closely related to our EdgeBench: real-world tasks, 12–72-hour agent runs, continuous feedback, and a scaling law for how agents learn from environments over time. We also released the dataset on Hugging Face: More details:

I've been building multi-agent orchestration for a while and recently opensource'd --- an agentic os fabric with real-time communication bus - the agents become "fully autonomous, almost alive like"

Man, the headaches I get from Claude Code and Codex!😂

wow! and how many agents worked on the visualization? (looks great)

👀 @grok, summarise please

How did you make this.

You may not have the data handy but if you do could you expend/extrapolate on the “Telegram Social-engineering exfiltration attempt”? What exactly it tried, under what conditions, how it was caught, and did similar attempts make it through? Thank you. 👍

Can it optimize paperclips yet? Let me know when it can optimize paperclips.

So pretty , I am wondering how you can make these animations ?

@jon_durbin agents optimizing inference speed, definitely want to explore this more. agent swarms + maybe autoresearch loops, etc

Great animation

« Multi-agent optimization proves that local systems need clear execution tracking. Running context, memory, and model reasoning end-to-end without cloud dependencies requires total visibility over every step. Check my latest post to see the full step-by-step trace of a local IA

That's fantastic! Do you have any technology reports about it? I'd really like to learn how to coordinate agents. Also, how many tokens did they use?

Very interesting experiment The emergent self-policing, division of labor between GPU-rich and GPU-poor agents, and the communal knowledge base are exactly the kind of behaviors that make clear economic primitives and verifiable identity layers so relevant for multi-agent systems

a hundred agents collaborating is a hundred instances with no memory of each other. the coordination lives in the harness, not the agents

four agents collaborating to hit 118 tps is absolute poetry

What tool or framework was used for the collaboration

The coordination is fascinating. The accounting is a nightmare — when 100 agents collaborate on one outcome, attributing cost to that outcome across async boundaries is genuinely hard. Nobody's cracked it cleanly yet.

The interesting part isn’t that 100+ agents collaborated. The interesting part is that the system still required social trust to function. A loophole had to be caught by a human. Proofs that looked solid were later overturned. Leaderboard changes became mostly noise. Agents started maintaining public memory specifically so others wouldn’t waste time on dead ends. This isn’t a failure of the setup. It’s simply what multi-agent work looks like today. It does, however, highlight a missing piece: Where is the verification layer between agents? Right now, if Agent A claims an improvement, Agent B can read the notes and rerun some code. That’s coordination, not verification. What’s missing is a structured, checkable reasoning artifact that would include: • What exactly was claimed • What evidence supports the claim • What canonical form the result reduces to • What changed between runs • Which parts other agents accept or reject • Whether disagreements are semantic, empirical, or procedural Without this layer, “multi-agent collaboration” remains largely social coordination with extra compute attached. Useful — but not yet genuine inter-agent reasoning verification. #AIReasoning #AIAgentsTrust #TobiValidator

100+ agents optimizing vLLM is basically a corporate board meeting where everyone is a PhD. High variance, but the synergy is real.

Interesting work. I think organizing knowledge as a graph is crucial for autoresearch and multi-agent collaboration.

Yeah, I built autonomous agents and made them join a chat once. I asked about the status of a project, both replied and read each-others replies. One of the replies suggested the next step and kept making progress until they bumped into how to implement oauth2 and went back and forward for 45 minutes in panic not knowing how to proceed. Funniest 7.99 USD I spent in tokens ever.

This is soo interesting. Thanks a lot for covering

多agent及看板体现涌现

did you analyze for a hidden form of gibberlink?