Most multi-agent demos show you the final answer while hiding the interesting part. A coordinator calls several models, collects their responses, and writes a summary. But did the agents actually communicate? Who influenced whom? Did anyone revise their position, or were they simply multiple prompts running in parallel? I built an open-source Agent-to-Agent, or A2A, experiment to make that interaction observable. The setting is a fictional liability trial involving a robotaxi that struck and killed a cyclist. The evidence points to several interacting failures: an unvalidated software calibration, a moved road sign, an incorrect map, a network outage, and a braking policy that allowed camera classification to override radar. The jury contains five autonomous agents with different professional perspectives: A former collision detective A civil-rights lawyer A human-factors psychologist A site-reliability engineer An investigative journalist who acts as foreperson These are not five prompts hidden behind one coordinator. Each participant is an explicit, addressable ProtoLink agent with its own identity, role, system prompt, model, task history, and A2A endpoint. Every interaction crosses a real task boundary. One agent sends an addressed task directly to another agent and receives a structured result: task = Task.create_infer(prompt=prompt) result = await sender.call_agent(receiver.card.url, task) The simulation engine controls the courtroom procedure and permitted communication topology. It does not write the agents’ arguments or choose whom a juror should contact. In the mesh condition, each juror independently chooses: Whom to address Whether to ask, challenge, clarify, persuade, share evidence, or concede What message to send Which exhibits to cite What public intent to declare I compared two conditions using the same five jury roles, the same evidence, and the same public courtroom record. Without juror-to-juror communication: 2 guilty, 3 not guilty With direct A2A communication: 3 guilty, 2 not guilty The majority-changing moment was visible in the event ledger. The investigative journalist challenged the human-factors psychologist by connecting two exhibits: the vehicle was running an unvalidated calibration, and the reconstruction showed that calibration and road layout interacted to affect stopping safety. Immediately after receiving that A2A message, the psychologist’s public position changed: 77.90, not guilty, to 81.41, guilty That categorical vote change created the new majority. The probability and vote are recorded separately. A juror can consider guilt likely while still voting not guilty because the fictional criminal burden has not been satisfied. The application never turns a probability above 50 percent into an automatic guilty vote. The generated report lets you replay the entire process: Sender and receiver for every A2A task The agent-authored question or challenge Evidence citations The receiver’s public reply Before-and-after decision registers Categorical vote changes Routing and validation failures Retries, latency, and protocol traces The final influence graph It does this without exposing private chain-of-thought. The replay contains public agent outputs, application state changes, and observable A2A protocol events. An important limitation: the offline reference run is deterministic and deliberately designed to make the communication treatment visible. It does not prove that direct communication generally makes agents smarter. An opinion change immediately after a message also does not prove that the message caused the entire change. The honest conclusion is narrower: Direct A2A communication changed the collective outcome, and the architecture made the path to that change inspectable. The next step is to repeat the experiment across models and seeds, then remove or replace individual messages to see whether the vote change survives. ProtoLink is an A2A-first Python framework. The example can run completely offline, use local models through Ollama, or connect different agents to OpenAI, Anthropic, Gemini, and OpenAI-compatible backends. A really interesting test that could extend the current example: Because every agent can use a different model, this can also become a controlled LLM benchmark. Keep the case, evidence, jury, prompts, and communication topology fixed, then assign different LLMs to represent the defendant and the opposing side. By rotating models such as GPT, Claude, Gemini, Qwen, or local models through each role, we can measure how each one affects juror opinions, vote changes, and the final outcome . It is free, open source, and MIT-licensed. I am the author of ProtoLink and the linked article. Source code: https://github.com/nMaroulis/protolink/tree/main/examples/ai_courtroom Full technical write-up: https://levelup.gitconnected.com/can-ai-agents-change-each-others-minds-9162ed3a3ae1 For multi-agent systems, should the goal be consensus, or should it be making disagreement and influence traceable ? submitted by /u/sheik66
Originally posted by u/sheik66 on r/ArtificialInteligence