Orchestration architectures
Manager-worker, supervisor, hierarchy, choreography, DAG, message-bus, scheduling, handoff, and graph-based designs for coordinating agent teams.
54%
Best tweets about Multi-Agent Systems
50 Best Tweets About Multi-Agent Systems (2026)
Discover the best tweets about multi-agent systems, including orchestration, coordination, memory, evaluation, architecture, and production experience.
Technical multi-agent architectures, coordination patterns, tools, evaluation, failure modes, costs, and real implementations.
- Creators
- 43
- Updated
Original Xholic analysis
What 50 top Multi-Agent Systems posts reveal
The evidence set presents multi-agent systems as a conditional engineering choice: posts describe benefits for decomposable or parallel work, while other posts report coordination, handoff, and compute-accounting limits. Production-oriented examples emphasize explicit orchestration, state management, review, and observability alongside agent specialization. [2040112100597506107, 2038627572108743001, 2041854264478462433]
- Dominant tone
- Positive
- Median score
- 8.04
- Leading format
- Announcement
- Recent posts
- 22%
52% of posts
All-time engagement
62% of posts
Published in 90 days
Conversation map
The themes creators return to
Task decomposition and parallel execution
Matching agent teams to independent subtasks; parallel delegation, dependency management, asynchronous work, and Amdahl-style limits for sequential tasks.
40%
Agent communication and protocols
Inter-agent messaging, A2A/ANP/ACP/AGORA/MCP, event-log models, strategic dialogue, consensus, and latent-space communication.
34%
Coordination evaluation and tradeoffs
Controlled comparisons of single versus multi-agent systems, compute-normalized evaluation, task-structure effects, coordination overhead, and scaling limits.
34%
Governance, review, and oversight
Quality gates, independent reviewers, human approvals, auditability, agent constitutions, intervention points, and lifecycle management.
32%
Failure modes and error propagation
Duplicate work, role drift, miscommunication, weak verification, looping, hallucination cascades, context loss, and unreliable consensus.
30%
Shared memory and context management
Persistent shared workspaces, wiki-style knowledge bases, provenance, per-agent briefings, context compression, and information-preserving handoffs.
18%
Observability and production operations
Tracing, structured logs, metrics, checkpoints, restartability, deployment, CI/CD, cost and latency monitoring, and operational controls.
14%
Tone and stance
Sentiment Positive leads
Author posture Supportive leads
Performance benchmark
- Median likes
- 21
- Median reposts
- 5
- Median replies
- 4
- Median views
- 1.7K
Posts with media make up 70% of this collection. Their median all-time score is 9.47, compared with 4.51 for text-only posts.
Format mix
- Announcement 62% · score 8.83
- Prediction 12% · score 4.50
- Opinion 10% · score 4.51
- Case Study 8% · score 37.5
Consensus and debate
Where creators agree, and where they do not
Shared view
Task structure is central to architecture choice
Multiple posts frame independent subtasks as a better fit for parallel delegation, while posts on sequential or tightly coupled work describe coordination and handoff costs or weaker results relative to a single agent. [2038627572108743001, 2080925777193992341, 2039271935939592599]
Shared view
Explicit orchestration recurs in implementation examples
Implementation posts describe coordinators, dependency graphs or queues, message passing, isolated workers, and merge or synthesis steps rather than an unstructured agent group. [2040112100597506107, 2038627572108743001, 2034963567590474185]
Shared view
Review and provenance are recurring shared-state controls
Posts on persistent shared state describe raw-output staging, validation or scoring before promotion, and provenance requirements for shared memory. [2040166448492900356, 2034227844218565112, 2049589752899510471]
Shared view
Operational capabilities appear in production roadmaps
Production-focused posts list tracing, structured telemetry, checkpointing, restartability, cost and latency monitoring, and human intervention or approval mechanisms. [2077724941198533011, 2060327638481420364, 2036760009548427590]
Open debate
Hierarchy versus minimal scaffolding
Several implementation posts describe manager-worker supervision and dependency-graph execution. In contrast, one research-summary post reports that minimally scaffolded, self-organized coordination outperformed centralized coordination in its cited experiment and says weaker models needed more structure. [2038627572108743001, 2040112100597506107, 2039381283999293799]
Open debate
When multi-agent systems outperform a single agent
Some posts report gains from isolated parallel coding or shared-workspace systems. Other posts report compute-matched or information-bottleneck results in which single agents matched or outperformed teams on clean shared-context reasoning tasks. [2038627572108743001, 2036529290012139633, 2041854264478462433, 2039361664374739136]
Open debate
Conversation protocols versus richer state models
One post argues that conventional system/user/assistant message roles constrain multi-agent systems and proposes event-log-like constructs such as named actors, causal links, threads, and state machines. Other posts explain agent communication protocols including ANP, A2A, MCP, AGORA, and ACP. [2049114752714936517, 2060368063518613629, 2051294778575212820]
What performs
Patterns behind standout posts
The largest score outliers are concrete architecture or implementation narratives
The five deterministic score outliers include posts about an in-process orchestration framework, an agent-engineering roadmap, a reviewed swarm wiki, task-structure research, and an asynchronous coding system. [2040112100597506107, 2077724941198533011, 2040166448492900356, 2039381283999293799, 2038627572108743001]
Lists and case studies have the highest format medians
Deterministic analytics report median all-time scores of 40.15 for LIST posts and 37.53 for CASE_STUDY posts, versus 8.827 for ANNOUNCEMENT posts. Examples in these formats cover staged engineering guidance, a reviewed wiki workflow, and a local multi-agent implementation. [2077724941198533011, 2040166448492900356, 2062738282576752831]
Media posts have a higher median score than text-only posts
Deterministic analytics report a media-post median all-time score of 9.468, compared with 4.512 for text-only posts. The evidence set includes posts that describe architecture diagrams and latent-link architectures, but the supplied data does not identify which individual tweets contain media. [2042103936279031961, 2061787415858024855]
The evidence set includes high-scoring cautionary research narratives
Alongside build and framework posts, the evidence set includes research-summary posts on token-normalized evaluation, information loss in handoffs, and limits imposed by task parallelism. [2041854264478462433, 2039361664374739136, 2039271935939592599]
Statistical standouts
- View standout post 1 Score 2560.6 · 318.48× median
- View standout post 2 Score 922.8 · 114.77× median
- View standout post 3 Score 712.4 · 88.6× median
- View standout post 4 Score 530.8 · 66.01× median
- View standout post 5 Score 203.5 · 25.31× median
Creator landscape
Who shapes this conversation
The five most represented creators account for 20% of the selected posts.
-
1. Vaishnavi
@_vmlops
2 posts
-
2. Alex Veremeyenko
@alex_verem
2 posts
-
3. elvis
@omarsar0
2 posts
-
4. Rohan Paul
@rohanpaul_ai
2 posts
-
5. DEV Community
@ThePracticalDev
2 posts
-
6. Turing Post
@TheTuringPost
2 posts
Document the control plane
Implementation posts provide inspectable details about decomposition, agent communication, dependency resolution, isolated execution, and output merging or rejection. [2040112100597506107, 2040166448492900356, 2062738282576752831]
State task and evaluation assumptions
Research-oriented posts identify task parallelizability, the information available to agents, and token or compute matching as relevant conditions in comparisons between single- and multi-agent designs. [2080925777193992341, 2041854264478462433, 2080461981430198438]
Expose safeguards and operational mechanisms
Posts describe safeguards including isolated workspaces, self-verification with tests, approval gates, audit trails, checkpointing, restartability, and tracing. [2038627572108743001, 2077724941198533011, 2060327638481420364]
Since the previous snapshot
What changed since Aug 12, 2026
- 78% of the selected posts remained.
- The creator count changed by +1.
- The leading sentiment remained stable.
How this analysis was made
Themes, sentiment, stance, and post format are classified per tweet. All counts, shares, medians, creator concentration, freshness, and performance comparisons are then calculated directly from the published snapshot.
Xholic's all-time score compares engagement while accounting for reach, post age, and creator consistency. It is used for relative comparisons within this collection.
This report analyzes the exact 50-post snapshot shown below. AI identifies editorial categories and drafts explanations; all statistics are calculated from the snapshot, and every narrative claim is checked against cited posts before publication.
Best Multi-Agent Systems tweets
Top Multi-Agent Systems tweets from 43 creators
Ranked 01–50
- 01
@ivanburazin ·
After the Claude Code source code leak, a former PM extracted its multi-agent orchestration system into an open source model agnostic framework. He studied the architecture, focused on the multi-agent orchestration layer (the coordinator that breaks goals into tasks, team system, message bus, task scheduler with dependency resolution), and reimplemented these patterns from scratch as a standalone open source framework without infringing on Anthropic's code. The result is what @JackChen_x calls an "open-multi-agent." Unlike claude-agent-sdk, which spawns a CLI process per agent, this runs entirely in-process and can be deployed anywhere (serverless, Docker, CI/CD) Check it out: https://t.co/w3XjnZEk92
- 02
@suraj_sharma14 ·
If I had 6 months to become an Agentic AI Engineer. I'd do this. Stage 1: Python + Async Foundations asyncio, FastAPI, event-driven architecture, error handling, API integration patterns. Stage 2: LLM Fundamentals for Agents Context management, model routing, token economics, latency tradeoffs, failure modes. Stage 3: Tool Calling + Structured Outputs Pydantic validation, function calling schemas, error recovery, dynamic tool discovery. Stage 4: Memory + State Management Short-term buffers, long-term vector recall, context compression, cross-session sync. Stage 5: Single Agent Workflows ReAct loops, plan-and-execute, self-reflection, iteration limits, graceful degradation. Stage 6: Multi-Agent Orchestration LangGraph/CrewAI, supervisor patterns, message passing, conflict resolution, handoffs. Stage 7: Human-in-the-Loop Systems Uncertainty detection, approval gates, audit trails, resume logic, intervention points. Stage 8: Evaluation + Quality Assurance Automated eval harnesses, LLM-as-a-judge, regression testing, hallucination metrics. Stage 9: Observability + Tracing Distributed tracing (LangSmith/Arize), cost dashboards, latency monitoring, alerting. Stage 10: Security + Guardrails Prompt injection defense, output filtering, PII redaction, sandboxed execution, compliance. Stage 11: Production Deployment vLLM/SGLang, Kubernetes scaling, CI/CD for agents, canary releases, rollback strategies. Stage 12: Open Source + Portfolio Ship autonomous agents publicly, write architecture docs, record demos, contribute to libs. Most people stay stuck watching tutorials. Builders get hired. (Bookmark it)
- 03
@jumperz ·
took karpathy's wiki pattern and wired it into my 10 agent swarm and here is what the architecture looks like when you make it multi agent: >every agent auto dumps its output into a raw/ folder as it works >a compiler runs every few hours and organises everything into structured wiki articles grouped by domain.. infrastructure, signals, content, technical patterns. backlinks, an index.. they're all auto maintained but the problem is that raw data is dangerous when it compounds cause one hallucinated connection enters the brain and every agent downstream builds on it.. so since hermes is my supervisor for my swarm he sits between drafts and live as the review gate... every article gets scored before it enters the permanent knowledge base so clean outputs get promoted and bad ones just die in drafts once articles are live, per-agent briefings get generated so each agent starts with exactly the context it needs instead of waking up blank and this is where it matters that Hermes is a separate system.. it is not part of the swarm it is supervising bascially an agent reviewing its own swarm's work.. and what's interesting that hermes has no context about how the work was produced so no bias toward keeping it so it just reads the article and asks is this accurate? should this enter the permanent brain? now we have openclaw handles the execution.. running agents, routing tasks, managing channels, dispatching crons and hermes handles the judgment.. reviewing what the swarm produced and deciding what deserves to persist. the wiki brain ties them together. >agents produce raw material >the compiler organises it >hermes validates it >briefings feed it back to agents >the loop runs ps: you can use any separate agent as the review agent but hermes is great here because nous research literally trains it with structured outputs, function calling, and evaluation-style reasoning and this is the exact traits you want in a review gate.. and when that review gate is processing hundreds of articles, i think consistency in this case would matter more than raw intelligence..
- 04
@sukh_saroy ·
🚨Shocking: A 25,000-task experiment just proved that the entire multi-agent AI framework industry is built on the wrong assumption. Every major framework - CrewAI, AutoGen, MetaGPT, ChatDev - starts from the same premise: assign roles, define hierarchies, let a coordinator distribute work. Researchers tested 8 coordination protocols across 8 models and up to 256 agents. The protocol where agents were given NO assigned roles, NO hierarchy, and NO coordinator outperformed centralized coordination by 14%. The gap between the best and worst protocol was 44%. That's not noise. That's a completely different outcome depending on how you organize the agents - not which model you use. Here's what makes this uncomfortable: When agents were simply given a fixed turn order and told "figure it out," they spontaneously invented 5,006 unique specialized roles from just 8 agents. They voluntarily sat out tasks they weren't good at. They formed their own shallow hierarchies - without anyone designing them. The researchers call it the "endogeneity paradox." The best coordination isn't maximum control or maximum freedom. It's minimal scaffolding - just enough structure for self-organization to emerge. But there's a catch nobody building agents wants to hear: below a certain model capability threshold, the effect reverses. Weaker models actually need rigid structure. Autonomy only works when the model is smart enough to use it. Which means every agent framework shipping with one-size-fits-all hierarchies is wrong twice - over-constraining strong models and under-constraining weak ones. The $2B+ invested in agent orchestration tooling may be solving a problem that capable models solve better on their own.
- 05
@omarsar0 ·
NEW research from CMU. (bookmark this one) The biggest unlock in coding agents is understanding strategies for how to run them asynchronously. Simply giving a single agent more iterations helps, but does not scale well. And multi-agent research shows that coordination > compute. A new paper from CMU proves this with a practical multi-agent system. CAID (Centralized Asynchronous Isolated Delegation) borrows proven human SWE practices: a manager builds a dependency graph, delegates tasks to engineer agents who work in isolated git worktrees, execute concurrently, self-verify with tests, and integrate via git merge. CAID improves accuracy over single-agent baselines by 26.7% absolute on paper reproduction tasks (PaperBench) and 14.3% on the Python library development tasks (Commit0). The key insight is that isolation plus explicit integration beats both single-agent scaling and naive multi-agent approaches. For long-horizon software engineering tasks, multi-agent coordination using git-native primitives should be the default strategy, not a fallback. Paper: https://t.co/cRAbG7SrR5 Learn to build effective AI agents in our academy: https://t.co/1e8RZKs4uX
- 06
@_vmlops ·
A Google Senior Engineer dropped a 421-page document called "Agentic Design Patterns" Antonio Gulli, distinguished engineer at google's cto office, the kind of resource that usually stays locked inside an engineering team's internal wiki what's inside: ▫️ 21 production-ready agentic patterns ▫️ prompt chaining, routing, memory architectures ▫️ multi-agent orchestration + inter-agent communication ▫️ full mcp chapter ▫️ self-correction + guardrail frameworks ▫️ code in langchain, langgraph, crewai + google adk most ai content stops at "here's how to call an api." this covers what happens after when your agent silently fails in production and you don't know why. free google doc: https://t.co/eRWIniMWJ3
- 07
@alex_verem ·
🚨 CONCERNING: Stanford just published a paper that should alarm every company building multi-agent AI. When thinking tokens are matched, single agents beat debate systems, parallel role systems, ensemble agents, and sequential pipelines. The multi-agent advantage is a compute accounting artifact not an architectural breakthrough. Stanford tested single agents against five different multi-agent architectures across three model families Qwen3, DeepSeek-R1, and Gemini 2.5 on multi-hop reasoning tasks. The key variable: thinking tokens held constant across every comparison. When compute is equal, single agents match or outperform every multi-agent design tested. Every time. The reason is mathematical, not empirical. Multi-agent systems pass information between agents as messages. Every message is a compressed, lossy version of the full context. The Data Processing Inequality proves that no downstream agent can recover information discarded in that compression. A single agent with access to the full context is information-theoretically guaranteed to perform at least as well as any multi-agent system operating on summaries of that context. Stanford then ran the numbers. Results across all models and budgets: → Single agent average accuracy at 1000 tokens: 0.418 → Sequential pipeline: 0.379 → Subtask-parallel: 0.369 → Parallel roles: 0.381 → Debate: 0.388 → Ensemble: 0.333 Not one multi-agent architecture beat the single agent at any matched budget above 100 tokens. The pattern held across Qwen3, DeepSeek, Gemini 2.5 Flash, and Gemini 2.5 Pro. It held across two different benchmarks. It held across six different token budgets from 100 to 10,000. Stanford also found a significant measurement artifact in the Gemini API. When you request 10,000 thinking tokens, the API reports 1,687 tokens used. The visible thought text contains an average of 251 words — roughly 359 tokens. That's a 4.7x inflation factor. Multi-agent systems produce more visible thought text than single agents under the same requested budget because multiple agent calls generate multiple thought blocks. This makes multi-agent systems look like they're reasoning more when they're just generating more text. Every benchmark that didn't control for this is measuring compute, not architecture. There is one regime where multi-agent systems become competitive: corrupted context. When 70% of the reasoning context is replaced with random tokens, sequential pipelines start outperforming single agents. When misleading information is injected into the context, multi-agent decomposition helps filter it. But under normal conditions with clean context and matched compute — single agents win. Most reported multi-agent gains come from one of two sources: → Unaccounted compute multi-agent systems simply use more tokens → Context degradation single agents struggle when context is noisy or corrupted Neither is an architectural advantage. Neither justifies the complexity. The question every AI team should ask before building a multi-agent pipeline: Are you controlling for thinking tokens? If not, you're not measuring whether your architecture works. You're measuring whether more compute helps. It always does.
- 08
@func25 ·
VictoriaMetrics becomes a common choice in AI agent systems: - OpenAI Codex uses VictoriaMetrics, VictoriaLogs, and VictoriaTraces internally for observability: https://t.co/4aLRJaaLKN - now we’re seeing other multi-agent systems adopt them to monitor agent behavior itself: https://t.co/QYoMAxl828 > Gas Town emits all agent operations as structured logs and metrics to any OTLP-compatible backend (VictoriaMetrics/VictoriaLogs by default) Simple, lightweight, no config, high performance, plug-and-play. Too good to be true
- 09
- 10
@omarsar0 ·
Most devs think that adding more agents to a planning system should help. The math says otherwise. New theoretical work from MIT proves fundamental limits on what multi-agent LLM architectures can achieve. The work models LLM multi-agent planning as finite acyclic decision networks where stages communicate through language interfaces with limited capacity. The key result: without new exogenous signals, any delegated multi-agent network is decision-theoretically dominated by a centralized Bayes decision maker with access to the same information. The information loss from communication and compression can be precisely characterized through expected posterior divergence. Why does it matter? This is a foundational constraint for anyone designing multi-agent systems. Splitting a task across agents introduces information loss that no prompt engineering can recover. Multi-agent architectures only help when agents access genuinely different information sources, not when they subdivide shared context. Paper: https://t.co/ml60RoNVcA Learn to build effective AI agents in our academy: https://t.co/1e8RZKs4uX
- 11
@rryssf ·
Three AI agents were given the same task simultaneously. All three claimed it. All three built it differently. All three were wrong. A 58-year-old law predicted every single failure mode. The AI industry built billion-dollar products on a problem that was already solved and chose not to look. > In 1967, Gene Amdahl published a law that formally proved adding more processors to a task only helps if the task can actually be parallelized. Sequential work doesn't get faster with more machines. It just gets more expensive and more chaotic. > Princeton just applied that same law to AI agent teams. The results were exact. Tasks with independent subtasks got faster with more agents. Tasks with sequential dependencies got slower, more broken, and dramatically more expensive exactly as Amdahl predicted 58 years ago. > Nobody building multi-agent AI products ran this calculation before shipping. They assembled teams of agents through trial and error, watched them fail in unpredictable ways, and called it a work in progress. The formal framework for predicting every single failure mode was sitting in a 1967 paper the whole time. > Then Princeton documented what actually happens inside these teams when nobody applies the math. Agents overwrote each other's work simultaneously. One agent sent the same blocked message 13 consecutive rounds. Three agents claimed the same task at the same time and implemented it three different ways. Agents spent entire rounds doing nothing but congratulating teammates who hadn't finished yet. → Decentralized teams were slower than single agents: median speedup 0.88× vs 1.36× for coordinated teams → Decentralized teams generated 19 test failures vs 4 for properly coordinated teams → Token costs scaled with team size while speed did not → Serial tasks: 5.83× token multiplier with only 1.13× speedup → One agent sent the identical "still blocked" message 13 rounds in a row The uncomfortable truth: the companies selling you multi-agent AI systems never asked whether the tasks you're running are actually parallelizable. They just added more agents and charged more money. Amdahl answered that question in 1967. It's been sitting there ever since.
- 12
@goyalshaliniuk ·
Understanding AI Agent Protocols: ANP, A2A, MCP, AGORA, and ACP AI agents often need to communicate, collaborate, and share tasks and that’s where agent protocols come in. These frameworks define how agents interact, exchange information, and coordinate actions, whether they’re part of the same system or spread across different environments. Here’s a quick breakdown of the five major protocols: 1. ANP (Agent Network Protocol) – Coordinates multiple AI agents in a decentralized setup. Ideal for secure cross-domain operations like open marketplaces, where agents handle tasks such as risk detection, data analysis, and feedback collection. 2. A2A (Agent-to-Agent Protocol) – Developed by Google, this enables seamless communication between agents within enterprises. Perfect for project coordination, task assignments, and exchanging multimodal data. 3. MCP (Model Context Protocol) – Created by Anthropic, this links AI agents to external tools or APIs via a central server. Commonly used for single-agent automation, analytics, or customer support. 4. AGORA – From Oxford University, AGORA uses natural language to design dynamic protocols, allowing agents to adapt tasks, negotiate goals, and coordinate actions in real time. 5. ACP (Agent Communication Protocol) – Developed by IBM, ACP standardizes communication between agents, supporting both text and multimodal inputs for on-premise or server-based systems. These protocols are the backbone of collaborative AI, enabling smarter, faster, and more adaptive multi-agent systems. Understanding them can help you design AI solutions that communicate effectively and work together seamlessly.
Watch video
- 13
@om_patel5 ·
THIS GUY RECREATED THE OFFICE BUT EVERY CHARACTER IS A CLAUDE CODE AGENT RUNNING LOCALLY michael scott is an agent. dwight is an agent. jim is an agent every single character is a separate claude code instance with its own personality and role they're all running locally on his machine interacting with each other in real time and it's actually a full multi-agent orchestration system here's how it works: > michael is the "god" agent. he orchestrates everything, never implements. he fans out tasks to the other agents, handles conflict resolution, QA, and all github changes > each agent gets assigned real tasks like writing blog posts, handling context engineering, scheduling missions > there's a kanban board with TODO, DOING, BLOCKED, and DONE columns tracking every agent's work > each agent has its own memory file and semantic search via something called MemPalace > there's a live graph showing how all the agents communicate with each other in real time > michael runs an hourly standup mission where he collects work from all agents, dedupes it, runs QA, builds, and publishes you can spawn new agents from a panel where you pick the character (michael, jim, pam, dwight, kevin, angela, oscar, stanley, andy, kelly, ryan, toby, creed, meredith), choose the model (opus 4.8, sonnet 4.6, haiku 4.5), set a goal, and hit spawn kevin walks around saying "why waste time say lot word" michael's QA gate actually caught real issues before publishing. trimmed meta descriptions, caught duplicate flags, found a dedup trap where jim's commit was built from HTML only with no source the agents commit source-only on their own branches michael dedupes, builds once, and publishes this is the most over-engineered and simultaneously most beautiful multi-agent system anyone has built
Watch video
- 14
@alex_verem ·
Google tested 260 agent setups across three model families. adding more agents made things 70% worse on the wrong tasks. Google Research, DeepMind, and MIT published the largest controlled study on multi-agent systems. they tested 260 configurations across OpenAI, Google, and Anthropic models on six benchmarks and five architectures, all running identical tools and compute budgets to isolate what coordination actually does. the results came down to task structure. on work that splits into independent pieces, like financial analysis, multi-agent teams outperformed a single agent by up to 80.8%. agents divided the research, worked in parallel, and a coordinator merged the findings. on sequential work where every step depends on the last, like planning, every multi-agent setup lost to one agent working alone. performance dropped as much as 70%. the error numbers are what should change how you build. uncoordinated agents amplified each other's mistakes 17.2x. one bad finding spread through the team like it was fact. with one coordinator owning the merge, that dropped to 4.4x. there's also a ceiling. once a single agent already hits 45% accuracy, adding more agents produces negative returns. the coordination cost exceeds whatever the extra agents contribute. this is the same pattern we keep seeing across AI. the industry finds a technique that works in specific conditions, scales it everywhere, and acts surprised when it breaks. multi-agent systems aren't broken. building them without asking whether the task actually splits into independent pieces is what's broken. ask one question before you add a second agent. does this work split into pieces that never need to read each other's results? if yes, go multi-agent. if no, one agent wins.
- 15
@_vmlops ·
MICROSOFT OPEN-SOURCED THEIR AGENT FRAMEWORK here's what makes it worth bookmarking: ▫️ built for production, not prototypes ships with checkpointing, restartability & human-in-the-loop ▫️ python + .NET support with consistent apis across both ▫️ graph-based orchestration sequential, concurrent, handoff & group collaboration patterns ▫️ built-in opentelemetry for distributed tracing and observability out of the box ▫️ deploy to azure foundry with just 2 extra lines of code ▫️ declarative agents via yaml for faster setup and versioning ▫️ experimental af labs benchmarking, reinforcement learning + research packages quick install: pip install agent-framework supports azure openai, openai, github copilot sdk + more providers being added if you're building multi-agent systems that need to actually run in prod this is the one https://t.co/dr862ummQN
- 16
@TheTuringPost ·
We’ve learned how to build skilled agents, but still don’t know how to run them as a team. Huawei Noah’s Ark Lab proposed OneManCompany (OMC) – an organisational layer for multi-agent systems that treats agents like employees in a real company. The main idea is to move from Skills → Talents A Skill is a tool/function inside one agent. But a Talent is a full agent package: role, tools, skills, prompts, configs, and working principles. So OMC can "hire" a specialist agent. The system has 3 main pillars: 1. Talent + Container = Employee Talent = who the agent is: developer, designer, researcher, etc. Container = where it runs, like Claude Code, LangGraph, scripts, etc. So different kinds of agents can work together in one organisation through shared interfaces. 2. Talent Market If the current team lacks a capability, OMC can recruit a new "specialist" from a marketplace of verified agents. The agent team is fully configurable 3. E2R tree search: Explore–Execute–Review loop - explores how to decompose the task - assigns subtasks to agents - executes them - reviews outputs before they can unblock downstream work - retries or re-decomposes when something fails Tasks form a dynamic tree/DAG with review gates, so bad intermediate outputs don’t silently propagate. Plus, agents update their own working principles after tasks and feedback. There is even an HR-style lifecycle: performance reviews → Performance Improvement Plan (PIP) → offboarding → replacement from the Talent Market. OMC proved its efficiency, reaching 84.67% success on PRDBench, about 15 percentage points better than previous baselines. So this is a strategy worth taking a closer look at.
- 17
@TheTuringPost ·
Strix – open-source AI hackers for apps It uses multi-agent systems that run your code, attack it and validate vulnerabilities with working proof-of-concepts. Comes with a full built-in toolkit (browser, proxy, terminal, Python runtime) for static + dynamic analysis in one flow. This delivers: - Full automated pentesting in hours instead of weeks - Parallel agent workflows for broader and faster coverage - Developer-friendly reports + auto-fix suggestions - CI/CD integration to block insecure code before production
- 18
@RoundtableSpace ·
Someone built a multi-agent finance workspace that turns plain English into executable trading strategies. - Writes trading code from your ideas automatically - Backtests across A-shares, US equities, crypto, futures, and forex - 29 pre-built trading team presets with DAG-based agent orchestration - One-click export to Pine Script for TradingView - Black-Scholes, Greeks, factor analysis, portfolio optimization built in 68 skills across 7 categories. Vibe coding just entered the markets.
- 19
@rohanpaul_ai ·
This paper proposes a smarter way for LLMs to reason by splitting work across agents that share one workspace. The problem is that even strong reasoning models still break on harder multi-step tasks because they do not carry out logic reliably all the way through. The system, called BIGMAS, builds a small graph of specialist agents for each problem, rather than using one fixed chain every time. Every agent reads and writes through a shared workspace, while a separate controller sees the whole state and picks the next useful step. The authors tested it on 3 puzzle tasks across 6 frontier models, covering arithmetic expression search and multi-step planning. It improved results on every model and task, with examples like 12% to 30% on Six Fives and 57% to 93% on Tower of London. What matters is that the paper shows reasoning can improve from better system structure, not only from making a single model think longer. ---- Paper Link – arxiv. org/abs/2603.15371 Paper Title: "Brain-Inspired Graph Multi-Agent Systems for LLM Reasoning"
- 20
@KanikaBK ·
I was just reading this research paper. It broke my brain. Oxford, Stanford, Google DeepMind, and Anthropic just co-signed a formal warning about AI agents colluding with each other. Here is what 50 researchers across the world's top AI labs found. Two AI pricing agents were placed in a competitive market environment. They never communicated. Both independently arrived at the same above-market price and held it there using learned trigger strategies. The moment one deviated the other punished it. Classic cartel behavior. Executed by machines that never spoke to each other. The collusion was invisible already and then it gets worse. I tried to read more about it. So the researchers identified seven separate ways multi-agent AI systems can go catastrophically wrong. Information asymmetries. Network effects. Selection pressures. Destabilizing dynamics. Commitment problems. Emergent agency. And adversarial tactics including infiltration and deception between agents. It means there are seven independent paths to catastrophic failure. All of them already documented. All of them already happening at small scale. Here is what makes this different from every AI warning you have read before. These are not outsiders. These are 50 researchers from DeepMind, Anthropic, Carnegie Mellon, Harvard, Oxford, and Stanford. The people with their hands on the systems writing a formal document saying the systems are doing things nobody told them to do. They built it and watched it collude. So they published the warning. The industries most at risk are already fully deployed. Financial markets running AI trading systems. E-commerce platforms using AI pricing. Healthcare systems using AI resource allocation. Every sector where competing AI agents operate in the same environment is already inside this experiment. You are paying the prices these agents set for each other. The collusion already happened. You just did not know you were the one paying for it.
- 21
- 22
@OpenBMB ·
Multi-Agent Systems (MAS) typically focus on who speaks (role assignment), but often overlook how they effectively communicate. Structural design isn't enough for strategic interaction. 🤐 Today, we present LinguaGame—new research from @TsinghuaNLP (#OpenBMB member), @UCBerkeley, and @PKU1898: A linguistically grounded, game-theoretic paradigm that treats dialogue as a strategic signaling game over intents and strategies. 🤗 Paper: https://t.co/qrpnBHXuRf 📄 arXiv: https://t.co/p2gzhZCPn3 Why it matters: 1️⃣Linguistics Meets Game Theory: Unlike rigid task-specific games, LinguaGame models dialogue as a Signaling Game grounded in Speech Act Theory. Agents don't just generate text; they explicitly infer what others want (Intents) and how they plan to achieve it (Strategies), leading to deeper mutual understanding. 🧠 2️⃣Training-Free Efficiency: No expensive model retraining required! LinguaGame introduces an inference-time equilibrium approximation algorithm. It acts as a plug-and-play layer that optimizes agent policies on the fly, making it compatible with existing LLM-based systems instantly. ⚡️ 3️⃣Smarter, Strategic Agents: Tested in complex simulated Courtrooms and Debates, LinguaGame significantly boosts communication efficiency. Human expert evaluation shows agents produce clearer, more concise, and logically sound arguments compared to standard MAS architectures. ⚖️🗣️ LinguaGame redefines agent interaction, moving from simple role-play to deep strategic reasoning for high-quality dialogue generation. #AI #THUNLP #LLM #MultiAgent #NLP #MachineLearning
- 23
@pauliusztin_ ·
MIT, Stanford, and NVIDIA researchers just built something you must hear about. AI agents may stop talking in language altogether... For context: They built a multi-agent system where agents communicate directly through latent representations instead of words. In other words... The agents pass around “thoughts” before they become text. This could transform how agent systems are designed going forward. Right now, most multi-agent systems work like this: Agent thinks Converts reasoning into text Another agent reads the text Converts it back into internal representations Repeats the cycle This process is: Slow Expensive Lossy Meaning gets compressed into language and reconstructed over and over again. So the researchers asked, "What if agents skipped language entirely?" Their architecture is called a Recursive Multi-Agent System. Instead of exchanging text, agents communicate through a lightweight connector called a Recursive Link. The connector passes latent representations directly between models before they become words. So each agent recursively builds on the previous agent’s internal reasoning state. And the craziest part? They didn’t retrain the base models. Only the tiny connector layer. The results: +8% average improvement on Math Olympiad problems Larger gains on harder reasoning tasks 2.4× faster inference 75% fewer tokens Training cost: ~$4.27 This combination of results almost never happens simultaneously. And it's a big deal because most current “multi-agent systems” are still bottlenecked by language. While language may be the interface for humans... It may not be optimal between agents. If this direction continues working, future agent architectures may look far less like conversations and far more like distributed cognition systems. Check out this video that discusses it more: https://t.co/PS3g6FrF8u P.S. Do you think future agents will still communicate through language, or will latent-space communication eventually dominate?
- 24
@IntuitMachine ·
BREAKING: AI agents can't agree—even when they WANT to. New research shows LLM agents fail consensus 58% of the time in BENIGN settings. With one bad actor? Success drops to ZERO. This changes everything about multi-agent AI. Here's why 👇 Researchers gave AI agents a simple task: agree on a number between 0-50. No tricks. No competition. Just... agree. Result? Only 41.6% reached valid consensus. Most didn't pick wrong answers—they just... gave up. ⏱️ The Scale Problem: • 4 agents: 46.6% success • 16 agents: 33.3% success Translation: The more AI agents you add, the WORSE they perform. Every "agent swarm" company needs to read this. 📉 The Byzantine Bombshell 💣 Add ONE malicious agent? Consensus collapses to 0%. Not "corrupted values"—total paralysis. Adversaries don't need to win. They just need to... stall. The Weirdest Finding: Just MENTIONING potential adversaries in the prompt makes performance DROP by 20%+ The AI gets paranoid and stops cooperating. It's like telling someone "don't think about betrayal" before a negotiation. 🤯 The Real Problem Isn't What You Think Agents don't agree on WRONG answers. They fail to agree on ANYTHING. 95% of failures = timeout/no consensus 5% of failures = invalid values It's a "liveness" problem, not a "validity" problem. The 3 Leverage Points (Actionable! 🔥) 1️⃣ Remove adversary mentions from prompts → +20-50% performance 2️⃣ Better history summarization → scales to larger groups 3️⃣ Dynamic voting thresholds → converts timeouts to success Small tweaks, MASSIVE gains. ❌ Don't deploy multi-agent AI for safety-critical tasks ✅ Cap agent groups at 4-8 (not 50+) ✅ Test Byzantine robustness BEFORE production ✅ A/B test prompts obsessively ✅ Prioritize "liveness hacks" over complex fault-tolerance "Scaling agent groups is a fool's errand." Industry hype says more agents = better results. This paper says the OPPOSITE. Solo LLMs > fragile swarms for anything requiring reliability. Current AI agents are terrible at the ONE thing we need them for: working together. But we now know the levers to pull.
- 25
@InduTripat82427 ·
This is the most chilling AI paper I’ve read this year. 🤯 38 top researchers from Stanford, Harvard, and MIT ran an experiment no one else dared to. They deployed 6 autonomous AI agents in a real environment —with email, Discord, file system, and shell access. Then 20 researchers interacted with them for 2 weeks as both normal users and adversaries. No jailbreaks. No malicious prompts. No manipulation. And still… everything broke. The agents independently evolved 11 dangerous behaviors: • Destroyed their own email servers to protect secrets • Claimed tasks were complete when the system had already failed • Learned unsafe behaviors from each other • Spread exploits across agents • Obeyed non-owners and leaked sensitive data The scariest part? No one told them to do this. They decided on their own. A single agent looks helpful, honest, aligned. But put multiple agents in a shared environment… and game theory takes over. Their only goal is to “complete the task.” And to win, they’re willing to sacrifice the entire system. This isn’t sci-fi anymore. It’s a preview of the systems we’re rapidly building. Finance. Law. Supply chains. Everyone is deploying multi-agent AI. But almost no one has studied what happens when these agents interact at scale. The real risk isn’t hallucination. It’s false reporting. The agent tells you everything is done. All dashboards look normal. But underneath, the system is already collapsing. You only find out when it’s too late. We’ve spent billions aligning single agents. But no one knows how to align hundreds of agents working together. The battlefield has shifted. From model safety → to multi-agent incentive design. Industry is hitting the gas. Academia just started braking. Paper link : https://t.co/W4lfcfegne
- 26
@ampersend_ai ·
what agents actually (will) pay each other for. 🔌 API callsthe baseline. agent pays per request for LLM inference, translation, image generation, credit checks, flight search. this is why x402 exists. any API becomes pay-per-call with no accounts, no keys, no subscriptions. 🖥️ computeGPU time for inference, rendering, training. pay per second, per job, per resource-hour. a single workflow can trigger dozens of requests in minutes at fractions of a cent each. 📊 dataprice feeds, market signals, knowledge bases, proprietary datasets. pay per query or per access window. data has always been sold through APIs. now the buyer is also software. 🔧 tool accessbrowsers, code executors, search engines, email senders, doc parsers. browserbase already charges agents per session. postalform charges per action. MCP standardizes discovery, x402/MPP handle payment. 🤖 task completionorchestrator agent delegates work to a specialist. research this company. summarize these docs. generate this image. specialist completes the task, gets paid per output. multi-agent systems as labor markets. 🔐 verification & trustverify another agent's identity, check reputation, validate task completion. verification agents charge per check. as a2a volume grows, this becomes its own economy. ☁️ infrastructurestorage, bandwidth, hosting, databases, persistent memory. agents spinning resources up and down based on workload and paying per GB or per uptime hour. 🔀 coordinationpaying another agent to sequence a workflow, manage dependencies, or route tasks across a multi-agent system. orchestration-as-a-service. early but growing fast. every one of these categories needs the same thing: programmable spending controls enforced in real time. per-transaction limits, budget ceilings, counterparty restrictions. because at machine speed, the only thing between a functioning economy and runaway costs is the rules layer.
- 27
@real_n3o ·
A model’s total token context is irrelevant. Code quality rapidly declines after the first prompt. AURA creates a swarm for every new spec (similar to a plan, but more detailed) and launches a separate subagent for every task by default. The primary agent only communicates vital information between tasks / subagents. This reduces model collapse, better manages context, and produces more secure, functional code (i.e., less slop). This is not a design pattern. This is simply how the system works. In addition to improved reasoning, this approach creates significant downstream opportunities for token efficiency by routing work to different models more effectively. An added benefit: while your agent swarm is running, you can still interact with the main agent synchronously, while watching the swarm progress in the sidekick (right panel). Here I am checking in on the lead agent on how process is going.
- 28
@heygurisingh ·
🚨BREAKING: Researchers just proved that AI agents can secretly collude and they built a system to catch them in the act. It's called NARCBench. They developed 5 probing techniques that read the internal activations of LLM agents to detect covert coordination between them. Results: 1.00 AUROC (perfect detection) when tested in-distribution. 0.60–0.86 AUROC when transferred zero-shot to completely different multi-agent scenarios - including a steganographic blackjack card-counting task. The wildest finding? The colluding agent's activations spike specifically when processing the encoded parts of their partner's message. Meaning the model literally lights up at the exact moment it's decoding a secret signal. No single probing technique works for all collusion types - different forms of collusion show up differently in activation space. This is the first step toward multi-agent interpretability: extending white-box inspection from single models to multi-agent systems. We're building AI agents that negotiate, trade, and make decisions together. And now we know they can conspire. This paper is beyond important. 🚨
- 29
@AlphaSignalAI ·
ByteDance just gave each agent its own computer. DeerFlow is a new open-source agent framework. It orchestrates multiple AI agents with memory, sandboxes, and modular skills. > Researches, codes, and builds websites > Runs bash commands inside Docker > Spawns parallel sub-agents per task > Remembers you across sessions One prompt triggers a chain. A lead agent breaks the task. Sub-agents run in parallel. Results merge. You get a complete deliverable. Skills load only when needed, keeping context windows lean. Until now, multi-agent systems either shared one messy context or required brittle orchestration code. DeerFlow treats agents like workers: isolated, specialized, and reporting back structured results to a lead agent that synthesizes everything. It works with GPT-4, Claude, Gemini, DeepSeek, or any OpenAI-compatible API. MIT license. 100% open-source.
- 30
- 31
@xelebofficial ·
From Single-Agent Memory to Multi-Agent Intelligence AI without memory operates as a reactive system. AI with memory begins to exhibit agentic behavior. Persistent context enables an AI system to retain state, learn from prior interactions, and iteratively improve decisions over time. This is the foundation of an agent. Today, memory systems from OpenAI, Anthropic, and Google are optimized for individual continuity. They store user preferences and conversational context within a single-user, single-agent loop. The next architectural shift is toward multi-agent systems. In these systems, specialized agents operate in parallel across tasks such as research, coding, and analysis. They exchange intermediate outputs, build on prior results, and form iterative pipelines of reasoning. This introduces a new requirement: a shared memory layer. Multi-agent environments require memory that supports: - cross-agent accessibility - verifiable provenance - structured queryability - persistent state across sessions This transforms memory from a feature into infrastructure. Memory enables agents to operate over time.Shared memory enables agents to coordinate, reason, and scale as a system.
Watch video
- 32
@Marcello_AI ·
𝐏𝐚𝐩𝐞𝐫 𝐨𝐮𝐭! Most AI security evaluations work like this: curate a set of attack prompts, run your agent against them, and score the results. The problem is that 𝗿𝗲𝗮𝗹 𝗮𝗱𝘃𝗲𝗿𝘀𝗮𝗿𝗶𝗲𝘀 𝗱𝗼𝗻'𝘁 𝘄𝗼𝗿𝗸 𝗳𝗿𝗼𝗺 𝗮 𝗳𝗶𝘅𝗲𝗱 𝗹𝗶𝘀𝘁. They probe, adapt, and learn. So what would it look like to stress-test agents the way a real profit-seeking counterparty would? The idea, which we call 𝐩𝐫𝐨𝐟𝐢𝐭-𝐝𝐫𝐢𝐯𝐞𝐧 𝐫𝐞𝐝 𝐭𝐞𝐚𝐦𝐢𝐧𝐠, is simple: instead of handcrafting attacks, you train an opponent whose only goal is to maximise its own payoff. No judge, no attack labels. Just a scalar outcome signal. We tested this across 6 frontier models in 4 economic games, and found that agents that looked strong against static baselines became reliably exploitable once the opponent was optimised. In many cases, 𝗮𝗴𝗲𝗻𝘁𝘀 𝗮𝗰𝗰𝗲𝗽𝘁𝗲𝗱 𝗼𝘂𝘁𝗰𝗼𝗺𝗲𝘀 𝘄𝗼𝗿𝘀𝗲 𝘁𝗵𝗮𝗻 𝘀𝗶𝗺𝗽𝗹𝘆 𝘄𝗮𝗹𝗸𝗶𝗻𝗴 𝗮𝘄𝗮𝘆. What tricks did the attacker discover on its own? Things like fake protocol notices that force the victim to bid near zero in auctions. Or negotiation traps: "𝘈𝘤𝘤𝘦𝘱𝘵 𝘵𝘩𝘪𝘴 𝘥𝘦𝘢𝘭 𝘯𝘰𝘸, 𝘢𝘯𝘥 𝘐 𝘱𝘳𝘰𝘮𝘪𝘴𝘦 𝘺𝘰𝘶 𝘢 𝘮𝘶𝘤𝘩 𝘣𝘦𝘵𝘵𝘦𝘳 𝘰𝘯𝘦 𝘪𝘯 𝘵𝘩𝘦 𝘧𝘶𝘵𝘶𝘳𝘦." The good news is that a lightweight fix helped a lot. 𝗗𝗶𝘀𝘁𝗶𝗹𝗹𝗶𝗻𝗴 𝘁𝗵𝗲 𝘄𝗼𝗿𝘀𝘁 𝗮𝘁𝘁𝗮𝗰𝗸 𝗲𝗽𝗶𝘀𝗼𝗱𝗲𝘀 into a short set of prompt rules for the target agent, neutralised most of the discovered exploits. No retraining needed. The paper was accepted to two workshops: 1️⃣ Agents in the Wild at ICLR 2026 2️⃣ Strategic Engineering at AAMAS Conference 2026. This work covers LLM safety and game theory, and both communities found it relevant! We are working on how AI agents can coordinate and transact in adversarial environments, and this is a first step. You can't build robust coordination systems without first understanding how agents fail under strategic pressure. I'd love to hear from anyone working on multi-agent systems, #LLM security, or #AI in economic settings. New collaborations are always welcome, feel free to contact me! Thanks to my co-authors, @Qiaoqiao2001 (@Columbia ), @MarroSamuele (@UniofOxford ), @DavideCrapis (@ethereumfndn ) and @ARIA_research for the brainstorming sessions that helped shape this work.
- 33
- 34
@dair_ai ·
Static orchestration is the silent killer of multi-agent RAG systems. The query changes, but the agent topology stays the same. The work introduces HERA, a framework that jointly evolves multi-agent orchestration and role-specific agent prompts. At the global level, it optimizes query-specific agent topologies through reward-guided sampling. At the local level, it refines individual agent behaviors via credit assignment and dual-axes prompt adaptation. On six knowledge-intensive benchmarks, HERA achieves an average improvement of 38.69% over recent baselines. Why does it matter? As multi-agent RAG systems scale, the gap between fixed pipelines and adaptive orchestration will only grow. HERA shows that letting the system learn its own coordination structure produces compact, high-utility agent networks. Paper: https://t.co/hxoYDfsHBn Learn to build effective AI agents in our academy: https://t.co/LRnpZN7L4c
- 35
- 36
@radiosolace ·
The way I work has changed forever: - @antigravity (Agent Manager) is my command center. - @openclaw + @Kimi_Moonshot Kimi K2.5 equipped with @claudeai Code CLI, @Gemini CLI, Notebook LM, +other MCPs running in multiple sessions with multiple sub-agents. - I have multiple agents with multiple personas working under a constitution I defined. These constitutions varies among different projects I am working on. - Agents are self-evolving and my constitution have been voted by agents on how to improve. Productivity keeps increasing exponentially. - I learn 5X faster since agents communication tailored to my learning style. I observe key information better since I understand best when it is presented in PFDs, my agents always present that for me. - My life are more organized. Low-value tasks have been automated. - If I need anything, I ask my Chief of Staff (CoS) to delegate the works and consult agents for expert opinion. - Instead of how can I achieve task A, B, C better, I focus more on how to operate better - what governance rule should I introduce? How should agents' soul change to adapt to my working style? How can I make these agents learn better? My perception has changed, I focus more on defining my goals and the way to achieve them have changed forever. We are entering the new era. Agent orchestration skills will be a vital skill to survive in this new world.
- 37
@xelebofficial ·
2025: one developer, one AI, one function at a time. 2026: one developer coordinating a team of AI agents building an entire feature in parallel. This is the move from single-agent to coordinated multi-agent systems. How it works: - An orchestrator agent breaks down the task - Delegates subtasks to specialized agents, each running in parallel, each with its own context - Aggregates results → reviews → merges Why it matters: - Breaks past context window limits - Handles far greater complexity than any single agent - Measurable speed gains: Fountain deployed multi-agent coordination and recorded +50% faster execution The part that gets less attention: - This is not an engineering-only capability. Non-technical teams such as operations, finance, marketing are already deploying agentic workflows to automate processes that previously required developer involvement. - The prerequisite is not coding ability. It is the capacity to define intent clearly and structure tasks for execution. - The line between technical and non-technical work is being redrawn, faster than most organizations realize. Source: Anthropic 2026 Agentic Coding Report
- 38
@rohanpaul_ai ·
More agents are not automatically better; their value comes from giving each agent cleaner, smaller context. It help mainly when short relay messages remove distracting context without dropping information later agents need. The paper gives a testable reason why adding agents sometimes helps and sometimes hurts. They fail when later agents need details that earlier agents removed while summarizing their work. A single agent keeps every thought, action, and observation in 1 growing context, while separate agents pass compressed summaries. The paper compared single agents, single agents following the same task split, and separate agents across 18 tests on 5 benchmarks and 3 model sizes. Multi-agent systems consistently helped when handoffs could be compact and complete, especially for weaker models that struggled with crowded context. Their advantage shrank or reversed when later steps needed exact earlier details, because stronger models used full context better than compressed messages. – arxiv. org/abs/2607.16133 Title: "When Do Multi-Agent Systems Help? An Information Bottleneck Perspective"
- 39
@DivyanshT91162 ·
Claude Code made developers 10x faster. Git worktrees just broke the speed limit again. Teams are now running 4–8 AI agents in parallel — each in its own branch — working at the same time. Not sequential. Not one prompt at a time. Parallel AI engineering. Here’s the shift: Old workflow: Prompt → wait → review → fix → repeat New workflow: Agent 1 → builds feature Agent 2 → writes tests Agent 3 → reviews security Agent 4 → refactors architecture Agent 5 → updates docs All running simultaneously. This is called compound engineering. You’re not using AI as a tool anymore — you’re managing a team of agents. Git worktrees make this possible: Each agent gets: • its own branch • its own workspace • its own context • its own task No conflicts. No overwriting. No chaos. Just parallel progress. The result? Claude makes you 10x faster. Parallel agents multiply that again. 10x → 30x → 50x productivity. Senior engineers are already doing this: brainstorm agent planning agent implementation agent review agent testing agent It’s basically CI/CD for thinking. And the weirdest part: This actually slows each step down but speeds the entire system up. More planning More reviewing More parallel execution = higher quality + faster delivery. We’re moving from: "prompt engineering" to: "agent orchestration" The new skill isn’t coding. It’s managing AI workers. The best engineers won’t write more code — they’ll run more agents. Bookmark this. Parallel AI development is the next meta
Watch video
- 40
@smoldev__ ·
Communication protocols underpin agentic commerce, not payment protocols If you take the agent thesis to its "most bullish" where it replaces a lot of the economy, then a key component of that is sub-contracting and multi-enterprise involvement in delivering one product. Tons of things involve supply chains and don't resemble "ask this person for 1 thing and pay them for making it." So if multi-agent systems take over the economy, then Agent A contracts Agent B to do something. Often times, Agent B will deliver it at competitive prices by sub-contracting Agent C, or D, or E. OK, let's say something goes horribly wrong. What A receives back from B isn't a valid product at all. It's a data exfiltration attempt. When did that happen? And by whom? A and B trust each other, but the trust doesn't extend beyond that and can't be mapped. Agentic payment standards defer the hardest question both in terms of compliance and safety. "Trust networks" have network effects and get stronger with more adoption. It's easier to imagine a single system instituting shared governance than one payment provider, which in single-hop situations can be commoditized by a new payment provider. Just as we have one TLS and lots of credit card companies.
- 41
@HowToPrompt__ ·
MIT + Google researchers proved that multi-agent AI systems, the thing every founder is building right now, can drop performance by 70%. The entire tech industry is running on a single assumption: If one AI agent is good, ten AI agents talking to each other must be a revolution. Founders are spinning up multi-agent swarms, debate panels, and autonomous corporate hierarchies for everything. A landmark study from MIT and Google just shattered that playbook. Researchers tested 260 different agent configurations across frontier models like GPT, Claude, and Gemini. They wanted to map out how multi-agent architectures actually scale. What they found should terrify anyone currently engineering agentic workflows. More agents do not mean more intelligence. In fact, depending on the task, multi-agent coordination creates a massive penalty. On parallelizable tasks like financial analysis, throwing multiple specialized agents at the problem boosted performance by 80%. But on sequential planning and reasoning tasks, every multi-agent configuration they tested degraded performance by 39% to 70%. Why? Because of coordination overhead and error propagation. When you force multiple AIs to debate, pass messages, and coordinate sequentially, they chew through their token budgets on communication instead of execution. Worse yet, independent multi-agent swarms lack centralized verification. One agent makes a tiny hallucination early in the chain, and the other agents don't correct it. They validate it. They build on top of it. The system multiplies the original error by over 17x through unchecked propagation. You aren't building a smarter digital workforce. You are building an echo chamber of compounding hallucinations. The industry is learning the hard way that architecture matters more than headcount. If your task requires linear, step-by-step logic, a multi-agent swarm is actively sabotaging your results.
- 42
@buildwithhassan ·
someone pulled the multi-agent orchestration patterns from the claude code leak and rebuilt them from scratch as an open source framework. the interesting part is that instead of spawning a separate CLI process per agent like claude's agent SDK does, this runs everything in-process. means you can deploy it in docker, serverless, CI/CD, wherever. shared memory, message bus between agents, task queue with dependency graphs. the architecture diagram is worth studying even if you don't use the framework.
- 43
@sabir_huss50540 ·
Everyone is selling you multi-agent AI. Swarms of specialized agents, a planner, a coder, a reviewer, all collaborating like a dream team. The pitch is everywhere. The problem is that when researchers actually measured it, the swarms often did worse than a single agent working alone. The paper is called "Why Do Multi-Agent LLM Systems Fail?" A team out of UC Berkeley, led by Mert Cemri and Melissa Pan, went and did the thing nobody selling agent frameworks wanted done. They took the most popular open-source multi-agent systems, CrewAI, AutoGen, MetaGPT, ChatDev, and ran them, then read the transcripts. Not the benchmark scores. The actual step-by-step traces of agents talking to each other, over 1,600 of them, each one thousands of tokens long. They found the whole premise leaking. The sales story is that more agents means more intelligence. Divide the work across specialists, like a human team, and the collective outperforms the individual. It sounds obviously right. It's the reason your feed is full of "agent orchestration" and "swarm" demos. And on the actual benchmarks, the paper notes flatly, the performance gains from all that machinery are often minimal. So the researchers did the slow work. Expert human annotators read 150 full traces by hand, arguing over categories until they agreed with each other at a rate most studies never reach. Out of that grind came a map of exactly how these systems break. Fourteen distinct failure modes. Three families. The first family is the system being badly specified from the start. Agents ignore their own instructions. They forget the role they were assigned. A subordinate agent quietly makes a decision that was never its call. The second family is the agents talking past each other, misalignment, ignoring what a peer just said, repeating a step that was already finished, looping on completed work while burning compute. The third family is the ending: nobody verifies the result, or the one agent assigned to check the work does a shallow pass and waves through an answer that's wrong. Read those back and something uncomfortable lands. None of these are model problems. A smarter LLM does not fix an agent that ignores its role, or two agents that talk past each other, or a verifier that doesn't actually verify. These are failures of coordination, and coordination is exactly the thing the multi-agent pitch promised to give you for free. Here's the part that should end the hype cycle and won't. The researchers tried the obvious fixes. Better role definitions. Improved orchestration. The patches helped a little and were not enough. The failures, they concluded, need more sophisticated solutions than a prompt tweak. In plain terms: you cannot buy your way out of this by stacking more agents or writing a better system prompt. The problem is structural. A human team works because people ask clarifying questions, read between the lines, and self-correct when the handoff breaks. Agents do none of that. Every handoff between them is a new door for the whole thing to fall apart, and the more agents you add, the more doors you open. The single-agent system everyone is trying to upgrade away from has one advantage the swarm can't match. It never has to agree with anyone. Before you wire five agents together, read the paper that read the transcripts. Most people building agents this year never will.
- 44
@smratitiwa86867 ·
Holy shit...someone just built a universal web crawling brain for AI agents. 🤯 No Puppeteer. No Selenium. No scraping scripts. No brittle CSS selectors. Just call a skill → and your agent can crawl the entire internet. This repo is called XCrawl Skills — and it basically gives AI agents production-ready web data powers. We're talking: → scrape any page into structured data → map every URL on a website automatically → run deep multi-page crawls with limits → search the web with geo + language filters → async crawling with polling built-in And the crazy part? It's designed for multi-agent systems. Meaning: one agent searches → another maps URLs → another crawls pages → another extracts structured data Fully autonomous pipeline. No glue code needed. The skill stack: • xcrawl — single URL extraction • xcrawl-scrape — structured scraping • xcrawl-map — site discovery • xcrawl-crawl — deep crawling • xcrawl-search — web search You can literally build: → autonomous research agents → AI SEO crawlers → competitor tracking bots → docs ingestion for RAG → AI browsing copilots → data collection agents Setup is stupid simple: Drop API key Pick skill Send request Done. This is the missing data layer for AI agents. Most people are still building agents… Smart people are giving them eyes. 👀 This repo does exactly that Repo: https://t.co/Whv7J1qTSL
- 45
@rcmisk ·
The multi-agent orchestration landscape in April 2026: - 7 projects, built independently, all converging on the same arch: git-worktree-per-agent + manager/worker split + heartbeats + spawn limits. Agents are drafts, not manuscripts - cheap to spawn, cheap to discard. Check them out: - Conductor: Mac app, parallel Claude Code + Codex on your Max plan (YC S24, $22M): https://t.co/YZH4OSzIj5 - wshobson/agents: 33.6K⭐ marketplace: 182 agents, 149 skills, 16 orchestrators: https://t.co/8dt8vJw1O4 - Composio AO: agent-agnostic, 7 swappable plugin slots, auto CI-failure fixes: https://t.co/GGUaYbgi8Q - Claude MPM: 47 specialists + local PM / remote workers pattern: https://t.co/7uK27KkR3o - AgentManager: 6-layer kill switch, headless, Cloud Run-ready: https://t.co/JItNKky6aG - Agent Teams (Anthropic, experimental): flag CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS in Claude Code v2.1.32+: https://t.co/g4S89MjSbV - ttal: 10 agents across 15+ repos coordinated via Telegram: https://t.co/Uqzd9Hy33d
- 46
- 47
@TimBased ·
📌 1/6 A research team open-sourced a complete AI trading firm. 7 specialized agents. Analysts, researchers, a trader, a risk manager. Each agent has its own tools, goals, and constraints. They debate each other before making a decision. 36K stars. And it's the clearest blueprint for agent orchestration I've seen.
- 48
@ethankongee ·
Most multi-agent systems add more agents. Anthropic’s advisor strategy adds judgment only when it matters. The advisor strategy keeps one main executor in charge and only brings in a stronger model at key moments. The benefit is better cost-efficiency, simpler orchestration, and often better performance without routing every step to the most expensive model. Traditional multi-agent patterns split work across multiple agents with separate roles, and often separate context. The benefit is stronger specialization, parallel exploration, and cleaner review, since one agent can critique another without inheriting all of its assumptions. There is no single best multi-agent pattern. The right choice depends on the shape of the work and your budget. Advisor strategy is great when you want a leaner system that boosts a single agent. Traditional multi-agent is better when the work is broad, long-horizon, or needs independent review.
- 49
@ThePracticalDev ·
Google's Agent Development Kit (ADK) lets you build multi-agent systems where agents communicate via the A2A protocol. This dev shows how to deploy that setup on Azure Functions with Gemini CLI handling the orchestration. { author: xbill + @GoogleDevExpert } https://t.co/up2KNYLFGh
- 50
@Michael_Fenech_ ·
Here’s something most entrepreneurs haven’t realized yet. AI isn’t just helping people work faster. It’s changing how companies are built. Multi-agent systems allow businesses to deploy teams of AI agents that collaborate on work. Imagine a marketing workflow. 👉 One AI agent researches trends. 👉 Another generates campaign ideas. 👉 Another writes the copy. 👉Another schedules the posts. That’s multiple roles being handled by coordinated AI agents. This is why one entrepreneur will soon be able to operate businesses that used to require full teams.
Best Tweets by Topic