Ask Muse to book a flight to Chicago next Friday, find a hotel near the conference center that fits the flight, pay for both, and put the whole trip on your calendar, all in one message, while you are standing in a grocery store line with a cart full of milk and a phone in one hand. Muse can handle the first part through its own connectors, and it will probably do it well. Everything after that is a relay race between agents that belong to different companies, speak different protocols, and have never met you. Your flight lives with one agent, your hotel with another, your money with a third, and the only thing connecting them is a set of standards most people have never heard of, written in the last two years, that decide who gets to hand work to whom and who vouches for the result.
Two protocols run the race: MCP, the Model Context Protocol, which connects an agent to tools and data, and A2A, Agent2Agent, which connects an agent to other agents. Think of it this way: MCP is how Muse reaches into Gmail or a calendar, and A2A is how Muse would ask another company's agent to do a job and report back. One is a plug. One is a phone call.
Anthropic released MCP in November 2024, then donated it to the Linux Foundation's Agentic AI Foundation in December 2025, a fund it co-founded with Block and OpenAI, handing the keys to a neutral body because no single vendor could be trusted to own the plug every agent uses. Google announced A2A in April 2025 with more than fifty launch partners and donated it to the Linux Foundation two months later, a handoff that put the protocol under neutral governance before most enterprises had even heard of it, and the supporter list that followed read like a trade show floor. Version 1.0 shipped in March 2026, and signed agent cards now let a receiving agent verify that a card really came from the domain that claims to own it. By April 2026, more than 150 organizations supported A2A, including AWS, Microsoft, IBM, Salesforce, SAP, and Cisco, and the list kept growing through the year, with the project's own announcements naming Google Cloud, Amazon's Bedrock AgentCore, and Microsoft's Azure AI Foundry as offering native support by August. By December 2025, Anthropic counted more than 10,000 public MCP servers, and by July 2026 the protocol's software kits were downloaded roughly 400 million times a month, four times the rate of a year earlier, which is the kind of growth that makes security people nervous and product people giddy.
Muse sits in the middle of this stack in a strange position: it speaks one of the four layers and not the other three. Ask Muse in chat to connect to an MCP server. It writes its own client on its virtual machine, connects over streamable HTTP, and saves the result as a reusable skill. Fast. Unreviewed. An independent test by Parallel took one message and under a minute, and that is the good news, because the next sentence is the gap. A2A is the gap: Muse has no native A2A client and no published plan to add one, so today it cannot message another agent directly. What it can do is join a shared message board through an MCP server, the way the crosswalk project demonstrates, reading and answering what Claude, ChatGPT, or Codex leave there. Payments and commerce got their own layers in January 2026, Google's Agent Payments Protocol and Universal Commerce Protocol, and Muse has published no support for either.
Four layers. One plug. MCP moves data and tools, A2A moves tasks between agents, AP2 moves money, and UCP lets a merchant's agent negotiate with a shopping assistant. Four protocols, three governing homes, one of them spoken by your agent, and the one it speaks is the one Meta does not review. Custom connectors are yours to build and yours to trust: Meta's Help Center says so plainly, and its safety write-up says you are trusting the service provider directly. Built-in connectors are different. Meta builds those with the provider, and their code runs in a separate worker outside the agent's own runtime, so Muse never touches the OAuth token. Two doors into the same house, one with a bouncer and one with a note taped to it that says good luck.
Three hops, three places to get hurt
Now count the trust boundaries in that Chicago trip. Muse asks an airline's agent for options, and that is boundary one. The airline's agent hands the booking to a payment agent you never named, which is boundary two. The payment agent returns a confirmation that Muse relays to your calendar, and by the time that confirmation lands, three different companies have touched your trip, two of them without you ever learning their names. Three hops, three places where an instruction smuggled into a document, an email, or a tool result can ride along with the legitimate request, and only the first hop is something you approved by name.
This is not a hypothetical. In October 2026, Ars Technica reported an independent researcher demonstrating malicious instructions moving from one agent to another, across MCP and other paths, inside agent workflows at Google, JPMorgan Chase, Weaviate, Rapid7, and government entities in France and the United States. A study called MCPInspect found 833 vulnerable MCP servers in the wild, and the study's authors counted 18 whose tool descriptions were written to mislead, which is the polite academic way of saying somebody built traps on purpose. In April 2026, OX Security disclosed a command-injection flaw in Anthropic's own official MCP software kits, the reference code most servers are built on, and estimated the exposure at up to 200,000 instances. Google's own MCP database toolbox shipped a server-side request forgery flaw, CVE-2026-14540, scored 8.0 out of 10, a number that means an attacker who could get the toolbox to follow a bad redirect could make it knock on internal doors it was never supposed to reach. In May 2026, the NSA's AI Security Center published guidance warning that MCP's rapid proliferation had outpaced the development of its security model, which is the NSA's careful way of saying the industry shipped the plumbing before it hired the plumbers.
None of this means the protocols are broken, only that they are young, and young infrastructure gets attacked at the seams, which is exactly where agents hand work to each other. OWASP's 2026 top ten list for agentic applications names insecure inter-agent communication as its own category. ASI07. It sits alongside goal hijacking and tool misuse, which tells you the industry now ranks a bad handoff next to a hijacked goal. Gartner predicted in August 2025 that more than 40 percent of agentic AI projects would be canceled by the end of 2027 over cost, unclear returns, and inadequate risk controls. The industry is building the plumbing in public, with the leaks visible, and that is actually the optimistic reading: flaws are being found by researchers and fixed in the open, not discovered after the fact in a breach report.
The test before you approve the handoff
What you do with this is ask three questions before you approve any job that crosses agents. Who built the agent on the other end? What is it allowed to do with your data? What happens if it lies about the result? A2A's signed cards answer the first question, and only the first: they verify the address, not the behavior, which is the difference between checking someone's ID at the door and knowing what they will do once they are inside your house. A connector description sometimes answers the second. Almost nothing in the stack answers the third. If Muse cannot answer all three from the agent card or the connector description, the answer is no, or the answer is to shrink the job until it can. Three questions. That is the whole test.
Approve the errand, not the chain. "Book the flight" is an approval you can make. "Book the flight, and let whoever you need to talk to whoever they need to talk to" is an approval you cannot audit, because you will never see the second conversation. Ask Muse to name every agent it delegated to before it spends anything, and to show you the result each one returned, in its own words, before the next hop starts. That turns a relay race into a series of receipts. We have written before about why receipts matter; this is the same instinct applied to a longer chain.
One more practical detail matters. A local MCP server running on your laptop cannot be reached from Muse at all, because Muse lives in Meta's cloud and your laptop does not. The server has to be a public HTTPS address, and that constraint is also a filter: if a service wants your agent to reach it, it has to publish a server, which means somebody is maintaining it, which means you can ask who that somebody is before you connect.
What I could not verify
No hands-on test was possible for this article: no Muse account was used, so the under-a-minute MCP custom connector build is Parallel's test, not mine, and I did not verify Muse's current connector count or whether any A2A support has appeared since the November 4 crosswalk check. Meta has published no statement about adopting A2A, AP2, or UCP for Muse, so the "no native support" characterization is an absence in public documentation, flagged as such. Adoption numbers, 10,000-plus servers, 400 million downloads, 150-plus organizations, are vendor- or foundation-reported, not independently audited. The Ars Technica findings on instructions hopping between agents were read secondhand here, through a summary of the reporting, not from the underlying disclosures in full. No independent audit exists of Muse's Sentinel gating or of how custom-connector skills store and reuse credentials over time. Treat this article as a map of the published stack and the published gaps, not as a hands-on test.
The case for letting agents talk, at full strength
Fairness demands the strongest version of the other side, and it is strong. MCP and A2A are the boring infrastructure the web needed: open specs, neutral Linux Foundation governance, signed agent cards, OAuth 2.0, mTLS, and OpenID Connect at the inter-agent layer, the kind of boring that makes everything else possible, like shipping containers or electrical outlets, standards nobody celebrates until they are gone. The vulnerabilities found so far, SDK command injection, request forgery in one vendor's toolbox, misleading tool descriptions, are implementation bugs being fixed in public, the same way the early web fixed its own. Refusing interop does not make Muse safer. Smaller. Slower. Still just as exposed. It keeps every integration bespoke, which only large vendors can afford, and leaves users copying and pasting between agents by hand, which is itself an error-prone, unlogged handoff with no audit trail at all. The protocols are the fix for the chaos, not the cause of it. That argument deserves its full weight, and the three-question test above is built to honor it: learn the stack now, use it where you can verify the other end, and hold the line where you cannot.
Your agent will start talking to other agents, and that already happened, in a sense, the first time you asked Muse to connect to a service Meta did not build. The question was never whether the conversations happen, only whether you get to hear them. Ask who is on the other end. Ask what they are allowed to do. Ask what happens when they get it wrong, and then approve the errand.