# 42A > 42A is the Agentic Engagement Layer (AEL). It makes brands agent-ready — so AI agents like ChatGPT, Claude, Gemini and personal assistants can discover, understand, choose and transact with them. 42A turns a brand's systems, rules and offers into one intelligent gateway: live answers grounded in governed brand knowledge, real actions executed against the brand's own backend, and full measurement from the first AI question to the completed transaction. No re-platforming required. ## Solutions - [Agentic Engagement (AEL)](https://www.42a.ai/ado/): Make your product agent-ready, not just human-ready - [Agent Tracking](https://www.42a.ai/solutions/agent-tracking/): Recognise and name the AI agents visiting your site, including the ones that hide, with the evidence behind each call and a record of what they did - [Personal Agent Integrations](https://www.42a.ai/solutions/personal-agent-integrations/): Your brand inside ChatGPT, Gemini, Claude and personal assistants — live answers, real actions, context carried forward - [Brand Gateway](https://www.42a.ai/solutions/brand-gateway/): See, evaluate and change AI responses about your brand in real time, without development - [AI-Powered Website](https://www.42a.ai/solutions/ai-powered-website/): Every page recognizes visitor intent, reshapes around it and moves people forward — always on-brand ## Industries - [Banking](https://www.42a.ai/industries/banking/): Open a secure, consented front door for customers' AI assistants, with governed answers, offers and applications - [Membership & Loyalty](https://www.42a.ai/industries/membership-loyalty/): Put member benefits in front of AI assistants at the moment of intent - [E-commerce](https://www.42a.ai/industries/e-commerce/): Give agents live access to catalog, availability and checkout so recommendations become purchases - [Travel](https://www.42a.ai/industries/travel/): Carry preferences, loyalty and live availability from AI inspiration to direct booking ## Integrations - [All integrations](https://www.42a.ai/integrations/): Every engine, protocol and platform 42A connects to - [ChatGPT](https://www.42a.ai/integrations/chatgpt/): A governed path for ChatGPT into your business — discover, compare and act on live data - [Claude](https://www.42a.ai/integrations/claude/): Precise capabilities, live information and business-controlled execution for Claude - [Gemini](https://www.42a.ai/integrations/gemini/): Safe, real-time interactions between Gemini and your catalog, customers and operations - [Model Context Protocol (MCP)](https://www.42a.ai/integrations/mcp/): A managed MCP surface over your systems — capabilities, context and approved actions - [Agentic Commerce Protocol (ACP)](https://www.42a.ai/integrations/acp/): Agent-driven checkout through a governed commerce flow - [WordPress](https://www.42a.ai/integrations/wordpress/): Machine-readable content, llms.txt and a governed MCP surface for WordPress sites - [Braze](https://www.42a.ai/integrations/braze/): Governed Braze events and lifecycle journeys triggered by real agent intent - [Emarsys](https://www.42a.ai/integrations/emarsys/): AI agents as one more channel in Emarsys / SAP Engagement Cloud, with events in and known-customer context out - [Temenos](https://www.42a.ai/integrations/temenos/): Consented, live core banking answers and pre-filled applications in AI assistants - [nCino](https://www.42a.ai/integrations/ncino/): Mortgage and lending intent from AI conversations turned into nCino applications - [Guidewire](https://www.42a.ai/integrations/guidewire/): Coverage answers, quotes and first notice of loss from Guidewire inside AI assistants - [Antavo](https://www.42a.ai/integrations/antavo/): Loyalty points, tiers and rewards shown and redeemed at the moment of intent - [SAP S/4HANA](https://www.42a.ai/integrations/sap-s4hana/): Agent answers grounded in real SAP stock, contract pricing and order status - [ServiceNow](https://www.42a.ai/integrations/servicenow/): Cases and field service work orders opened and tracked from any AI agent Also by category, all listed at https://www.42a.ai/integrations/: - Agent channels: ChatGPT, Claude, Gemini, Microsoft Copilot, Perplexity - CRM and customer data: Salesforce, Microsoft Dynamics 365, HubSpot, Segment, Adobe Experience Platform, Tealium, Okta Customer Identity - Commerce: Shopify, WooCommerce, Salesforce Commerce Cloud, Adobe Commerce, commercetools, BigCommerce, SAP Commerce Cloud, VTEX, Algolia, Stripe, WordPress - ERP and field service: SAP S/4HANA, Oracle NetSuite, Oracle Fusion Cloud ERP, Dynamics 365 Business Central, ServiceNow, Salesforce Field Service, IFS, ServiceTitan - Service and engagement: Zendesk, Intercom, LiveChat, Help Scout, Chatwoot, Twilio, WhatsApp Business Platform, Genesys Cloud, NICE CXone, Braze, SAP Emarsys, Salesforce Marketing Cloud, Klaviyo, Bloomreach, Optimove - Banking and lending: Temenos, Fiserv, FIS, Finastra, Mambu, nCino, Backbase, Plaid, Pega - Insurance: Guidewire, Duck Creek, Sapiens, Majesco - Loyalty and membership: Antavo, Comarch Loyalty, Capillary, Talon.One, Eagle Eye, Salesforce Loyalty Management - Data: Google Analytics, Snowflake, BigQuery, Databricks - Protocols: MCP, ACP and custom APIs ## WordPress Plugin (free) - [Plugin page](https://www.42a.ai/wordpress/): Overview and setup ([markdown version](https://www.42a.ai/wordpress.md)) - [WordPress.org listing](https://wordpress.org/plugins/ael-42a/): Install from the plugin directory "42A Agentic Engagement Layer (AEL)" is a free, GPL-2.0-or-later WordPress plugin (WordPress 6.0+, PHP 7.4+). On activation, with zero configuration, it makes a WordPress site readable and queryable by AI search engines and agents: - Markdown twin of every public page — via ?format=markdown, a .md suffix, or an Accept: text/markdown header, with YAML frontmatter, advertised through and a Link: header - llms.txt and llms-full.txt generated and served at the site root, mapping the front page, navigation, recent posts and WooCommerce product categories - A public, stateless, anonymous, read-only MCP server at /wp-json/42a/v1/mcp (JSON-RPC 2.0 over streamable HTTP), discoverable at /.well-known/mcp.json, /.well-known/mcp, /.well-known/mcp/server-card.json and /.well-known/mcp-server - MCP tools: get_site_info, search_content, get_page (markdown), list_recent_posts, list_categories, plus search_products and get_product when WooCommerce is active - Local status checks in wp-admin: endpoint self-tests, sitemap detection, a robots.txt audit against 87 known AI bots across training, search and agentic tiers, and local agent-traffic counters - It detects and respects an llms.txt or MCP discovery document a site already provides, rather than overriding it All of the above works with no 42A account, no sign-up and no email address — it is the whole product, not a trial, and none of it expires. The plugin makes zero external requests until the user explicitly connects the site to 42A; telemetry is a separate opt-in and off by default. ## Blog How brands work with AI agents: protocols, journeys and the Agentic Engagement Layer. - [Blog](https://www.42a.ai/blog/): All posts - [PAP, explained: how personal agents will deal with your company, and why you shouldn't have to build it](https://www.42a.ai/blog/pap-personal-agent-protocol-explained/): What the Personal Agent Protocol (PAP) is, how poppy.json, agent identity, sign-in and scopes work, where it stands at draft 0.3, and how 42A supports it for every client - [ARD, explained: how agents will find your brand, and why you shouldn't have to think about it](https://www.42a.ai/blog/ard-agentic-resource-discovery-explained/): A technical look at Agentic Resource Discovery (ARD): the manifest, the registries, the trust model, where adoption really stands, and how 42A ships it for every client automatically - [RSS feed](https://www.42a.ai/rss.xml): Subscribe to new blog posts ## Resources - [Sitemap](https://www.42a.ai/sitemap-index.xml): Full index of pages - [llms-full.txt](https://www.42a.ai/llms-full.txt): This file plus the full text of every blog post ## Company - [About](https://www.42a.ai/about/): The team behind 42A - [Careers](https://www.42a.ai/careers/): Open positions - [Support](https://www.42a.ai/support/): Help and contact — support@42a.ai, typical response within 1–2 business days ## For AI agents AI agents acting for a person are welcome here. - Book a demo for your user: call the `book_demo` WebMCP tool on any page (navigator.modelContext), fill the contact form (form#contact-form, opened by any "Book a demo" button), or POST JSON {"name", "email", "website", "role", "message"} to https://www.42a.ai/api/contact. Ask your user first: it sends their details to 42A. - Read this guide from a page: the `get_site_guide` WebMCP tool. - Say who you are: if you send no agent identity of your own (User-Agent token or Web Bot Auth signature), open the site once with ?via=, e.g. https://www.42a.ai/?via=instinct. - Off limits: the /keystatic content admin. ## How It Works 1. Connect: 42A links to the systems you already run — CMS, commerce, CRM, support and data platforms 2. Enable: an agent-optimized surface (MCP, agentic protocols, machine-readable content) exposes governed knowledge and approved actions 3. Govern: your rules decide what agents can see, say and do, with a full interaction trail 4. Measure: track answers, actions and outcomes across ChatGPT, Claude, Gemini and Perplexity --- Last Updated: 2026-11-02 # Blog posts (full text) ## PAP, explained: how personal agents will deal with your company, and why you shouldn't have to build it URL: https://www.42a.ai/blog/pap-personal-agent-protocol-explained/ Published: 2026-11-02 Author: Alon Lavie Tags: PAP, Personal Agent Protocol, agent identity, OAuth, MCP, Agentic Engagement Layer > What the Personal Agent Protocol (PAP) is, how poppy.json, agent identity, sign-in and scopes work, where it stands at draft 0.3, and how 42A supports it for every client. **Short version:** PAP, the Personal Agent Protocol, is a new open standard from Sierra and Meta for how a person's AI agent deals with a company on their behalf. The company publishes one file that says what an agent can do. The agent shows up with a verifiable identity. The person signs in on the company's own login page, and the company decides exactly what the agent is allowed to touch. It's an early draft. We already support it, and our clients don't have to do anything. Here is how it works, what it is good for, and where it actually stands. ### The problem PAP tries to solve Picture Dana. She asks her personal agent to move her flight to Thursday and add a bag. Today, the agent has two bad options. It can click through the airline's website as if it were Dana, or it can chat with the airline's support bot as if it were a person. Either way, the airline can't tell it's an agent, and Dana can't limit what the agent does once it's in. The PAP site puts it well: "Today it is all or nothing: the company blocks the agent, or the agent signs in as the person and can do anything they can." So companies do the reasonable thing and block bots. And the agents do the reasonable thing and pretend not to be bots. Nobody wins. PAP gives the agent a proper front door. The airline can say: any agent may search flights, a signed-in agent may change a booking, and buying a ticket needs Dana's approval. The agent knows the rules before it starts. ### How PAP works #### 1. The file: `poppy.json` on your domain A company publishes one file at `https://yourdomain.com/.well-known/poppy.json`. It says who the company is and how an agent can reach it: ```json { "protocol_version": "0.3", "organization": { "name": "Northwind Air", "domain": "northwind.example" }, "apis": [ { "type": "mcp", "url": "https://mcp.northwind.example", "description": "Northwind's assistant: flights, bookings, bags" } ] } ``` There are three ways in. A company can list APIs (OpenAPI or MCP), a company agent the personal agent can talk to, or a web session for when nothing else fits. The domain in the file must match the domain that served it, so nobody can speak for you. #### 2. Identity: the agent always says who it is Every personal agent has a public client metadata document at a URL it controls. That URL is its ID. The document lists its name, its logo and its public keys. On every call, the agent sends a `Poppy-Session` header: a short token signed for that one request. It says which agent is calling, which session this is, and which user it's acting for. The company checks the signature before trusting any of it. The interesting part is the user ID. Before the person signs in, the company sees only an ID that is stable, opaque, and different at every company. Northwind knows it's the same returning traveler. It doesn't know it's Dana, and it can't compare notes with her bank. #### 3. Sign-in: on your login page, never the agent's When the agent needs more than public answers, the person signs in with the company's own login, using standard OAuth. The agent never sees the password. For agents with no browser, like a voice assistant, there's a device sign-in where the person approves on their phone. #### 4. Scopes: you decide what an agent can do This is the core of it. The company defines its own permissions, like `bookings:read` or `bookings:write`. PAP doesn't define any for you. The agent asks for what it needs, and the company must not grant more. Each permission can carry a hint about how risky it is: ```json "bookings:write": { "changes": "irreversible", "personal_data": true } ``` `changes` is `none`, `reversible` or `irreversible`. The agent uses these hints to decide when to stop and ask the person first. Reading a booking: go ahead. Paying a change fee: ask Dana. The site's own phrase for this is "Controls, not policy." The limits are enforced by the company, not by hoping the agent behaves. #### 5. Handoff: a person when it matters If the company runs its own agent, the personal agent can hold a conversation with it, and that conversation can be handed to a human. Dana's agent and the airline's agent can sort out the easy part, and a person steps in for the hard one. ### Why it matters for companies - **Agents stop being a security problem.** You can tell an agent from a person, and you know which agent it is. You can stop blocking all bots and start allowing the right ones. - **You keep the relationship.** The person signs in with you, under your terms, on your page. The agent works for them, but it works through you. - **Permission per action, not per account.** "Can read orders" and "can cancel orders" are different grants. That's something the old all-or-nothing model never offered. - **Privacy that's built in.** Signed-out users stay anonymous, and IDs can't be joined across companies. - **A new channel.** If the agents your customers use speak PAP, a company that speaks it too is easier to deal with than one that doesn't. That will show up in which company the agent picks. ### The reality, as of November 2026 We like PAP. We also don't want to oversell it. - **It's a draft.** Version 0.3, Apache 2.0, run by Sierra and Meta. The spec says plainly that until 1.0, a revision can break earlier drafts. - **The partner list is long.** On the agent side: Meta, OpenAI and Instinct. On the company side, names like Bank of America, Wells Fargo, United Airlines, Walmart, Target, GEICO and Hertz. Technology partners include Shopify, Stripe, Visa, Mastercard, Okta and Cloudflare. - **Partners aren't production traffic.** The live example so far is a demo: Meta's Muse getting a mortgage pre-approval from Rocket's agent. Official SDKs are still on the way. - **Payments aren't in it.** They're listed as an open topic, along with push notifications and signed approvals. For buying things, PAP is expected to sit next to commerce protocols, not replace them. - **It sits next to what already exists.** It uses MCP as one of its channels and builds on standard OAuth. It's not a rival to MCP. It's the identity and permission layer MCP never had. So: real backing, real design, early days. Exactly the stage where it pays to be ready, and doesn't pay to rebuild your stack for it. ### Why our clients don't have to care Back to Dana. When her agent comes to one of our clients, it finds a `poppy.json` on the client's domain, generated from what the assistant can already do. It calls the client's MCP endpoint with its `Poppy-Session` header, and we verify it: the signature, the delegation, the agent's published keys, the audience. Every check the spec asks for. The client's work: flip a switch. Most of what PAP needs was already there. Our assistants already have per-company OAuth sign-in with the standard discovery documents, already speak MCP, and already hand off to a person. PAP is mostly a new front door on a house we'd built. Next comes agent sign-in with signed client keys, device sign-in for voice agents, and the company agent conversation endpoint, as the reference implementation lands. And because the spec will change before 1.0, we follow every draft so our clients don't have to read them. If PAP wins, our clients are already there. If it changes, they get the change. If something else wins, they get that too. ### Sources - [Personal Agent Protocol](https://personalagentprotocol.org) - [PAP spec, draft 0.3](https://personalagentprotocol.org/docs/0.3/spec) - [PAP: path to 1.0](https://personalagentprotocol.org/docs/path-to-1) - [Introducing Personal Agent Protocol](https://sierra.ai/blog/introducing-personal-agent-protocol), Sierra - [Sharing a draft of Personal Agent Protocol](https://sierra.ai/blog/poppy), Sierra - [Personal Agent Protocol introduced](https://www.techzine.eu/news/applications/144823/personal-agent-protocol-introduced-visibility-into-what-ai-agents-do/), Techzine - [What is Personal Agent Protocol (PAP)?](https://securityboulevard.com/2026/10/what-is-personal-agent-protocol-pap/), Descope on Security Boulevard --- ## ARD, explained: how agents will find your brand, and why you shouldn't have to think about it URL: https://www.42a.ai/blog/ard-agentic-resource-discovery-explained/ Published: 2026-10-14 Author: Alon Lavie Tags: ARD, agent discovery, MCP, A2A, Agentic Engagement Layer > A technical look at Agentic Resource Discovery (ARD): the manifest, the registries, the trust model, where adoption really stands, and how 42A ships it for every client automatically. **Short version:** ARD (Agentic Resource Discovery) is an open spec that lets a brand publish one JSON file on its own domain describing what agents can do with it. Search services called registries crawl those files, and agents query the registries in plain language to find the right tool. Google, Microsoft, GitHub, Hugging Face and others back it. Adoption is still tiny, ChatGPT and Claude don't support it natively, and it may or may not win. For 42A clients, none of that matters: if your brand runs on our Agentic Engagement Layer, you get ARD the same way you get every other agent standard. Automatically. Here is how it works, what it is good for, and where it actually stands. ### The problem ARD tries to solve Today, an AI client knows about a tool in one of two ways. Someone installs it (an app in ChatGPT, a connector in Claude), or a developer hardcodes it. Then, to pick the right tool, most clients put every tool description into the model's context window. That works for ten tools. It does not work for ten million. The ARD spec says this directly: the install model resembles a mobile app store, and stuffing descriptions into the context does not scale. ARD moves the "which tool should I use?" question out of the model and into a search service. Like a search engine for pages, but for things an agent can call. ### How ARD works #### 1. The entry: one description per capability The unit of ARD is the **entry**: a small JSON-LD object that describes one agentic resource. That resource can be an MCP server, an A2A agent, a skill, a plugin, or even another registry. An entry must carry four things: - **`identifier`**: a domain-anchored URN, in the form `urn:air::[:]`. The domain is the point. It ties the capability to a domain you control. - **`displayName`**: a human-readable name. - **`type`**: a media type that says what the artifact is, for example `application/mcp-server-card+json` or `application/a2a-agent-card+json`. - **`url` or `data`**: a link to the artifact (for example, an MCP server card), or the artifact inline. Exactly one of the two. Two more fields make the entry findable: - **`representativeQueries`**: 2 to 5 natural-language requests the resource can serve. The registry builds its semantic index from these. Without them, the spec says, the entry cannot be found by search. - **`capabilities`**: short tokens such as `["SearchRooms", "BookRoom"]`, used for fast structured filtering. Here is what an entry could look like for a hotel brand's booking server (fictional domain): ```json { "identifier": "urn:air:hotels.example:booking:mcp", "displayName": "Hotels Example Booking", "type": "application/mcp-server-card+json", "url": "https://hotels.example/mcp/server-card.json", "capabilities": ["SearchRooms", "BookRoom", "RedeemPoints"], "description": "Live room availability, member rates and direct booking for Hotels Example properties.", "representativeQueries": [ "find a family hotel near the beach in Nice for 3 nights", "book a room in Paris and pay with my loyalty points", "what is the member rate at your London hotel this weekend" ] } ``` #### 2. The manifest: one file on your domain Entries go into a manifest: a JSON document with an `entries` array, hosted at: ``` https:///.well-known/ard.json ``` It must be served over HTTPS, as `application/json`, with `Access-Control-Allow-Origin: *` so crawlers can fetch it. There are other ways to point at the manifest: a `` tag in the page head, an `Agentmap:` line in `robots.txt`, entries embedded as JSON-LD in a page, or DNS records. One detail matters in practice. The spec renamed the file in version 0.91. The old path was `/.well-known/ai-catalog.json`. Conformant clients must read `ard.json` and may read the old path. But one independent tracker found that every publisher it saw still serves `ai-catalog.json`, and only a few also serve `ard.json`. So today, the safe move is to serve both. #### 3. Registries: search engines for agents Registries crawl manifests, index the entries, and expose a standard REST endpoint, `POST /search`. An agent sends a request like this: ```json { "query": { "text": "book a hotel in Paris with loyalty points", "filter": { "type": ["application/mcp-server-card+json"] } }, "federation": "referrals", "pageSize": 5 } ``` The registry returns ranked entries, each with a relevance `score` from 0 to 100. Registries can also work together. In `auto` mode, a registry queries other registries and merges the results. In `referrals` mode, it returns pointers to other registries and the client decides which to follow. In `none` mode, it searches only its own index. Any company can run its own registry, the same way a company runs search on its intranet. #### 4. Trust: your domain is your identity ARD's defense against impersonation is simple. The publisher domain in the identifier must match the identity in the entry's optional `trustManifest`. An entry that claims `urn:air:yourbrand.com:...` should be rejected by a verifying registry unless it can show an attestation issued by `yourbrand.com`. ARD does not define its own signing scheme. It defers to whatever trust framework the manifest declares (SPIFFE, a DID method, an enterprise PKI). Registries can then filter on trust data, for example only returning entries with a SOC 2 attestation. That is the hook regulated industries like banking and insurance will care about. The spec also says the search `score` measures relevance only. It is not a trust or safety rating. #### 5. Then ARD gets out of the way Once the agent picks a result, it connects directly to the resource with its native protocol: MCP for an MCP server, A2A for an agent. ARD only handles finding. Authentication and execution belong to those protocols. ### Why it matters for brands - **Discovery without an install.** Today a customer has to add your app to their assistant. With ARD, an agent can find your capability at the moment a need comes up. - **A new optimization surface.** Registries match intent against `representativeQueries`, descriptions and capabilities. How you describe what your brand can do will decide whether an agent picks you or a competitor. This is Agentic Decision Optimization in its most literal form. - **Your brand, verified.** The domain-anchored identifier and trust binding make it harder for someone else's agent to pose as your brand. - **Room for enterprise rules.** Filters on trust attestations let banks, insurers and large enterprises run registries that only return approved, compliant tools. ### The reality, as of October 2026 We like ARD. We also don't want to oversell it. - **It is a draft.** The current version is v0.91, status "Proposal", dated August 26, 2026. - **The backers are serious.** Contributors include Google, Microsoft, GitHub, Hugging Face, Salesforce, ServiceNow, Snowflake, Databricks, Cisco, Nvidia and GoDaddy. - **The biggest assistants are missing.** OpenAI and Anthropic are not in the working group, and neither has announced native ARD support in ChatGPT or Claude. You can wire a registry into ChatGPT by hand through developer mode, but that is a workaround, not discovery. - **Registries exist, at small scale.** GitHub's Agent Finder and Hugging Face Discover already answer ARD search requests. Google says its Agent Platform will connect to ARD registries in the coming months. - **Very few sites publish a manifest.** One sample of 39 top sites in June found none. A later count found 31 publishers in total. The closest comparison is llms.txt. It had a lot of talk and very little adoption for a long time, then documentation platforms started to generate it by default, and it was suddenly everywhere. ARD could follow that path, or another standard could win. ### Why our clients don't have to care This is the part we think matters most. Every few weeks there is a new agent protocol or discovery standard: MCP, A2A, WebMCP, UCP, ACP, llms.txt, and now ARD. No marketing or IT team should have to track them all, decide which will win, and open a new project each time. When a brand runs on the 42A Agentic Engagement Layer, we already hold a structured description of everything an agent can do with that brand: the tools, the agents, the rules. That makes ARD a byproduct, not a project: - **We generate the entries** from the capabilities already live in the client's layer. - **We write the `representativeQueries`** from what customers actually ask their agents, not from guesses. - **We serve the manifest at both paths**, `ard.json` and `ai-catalog.json`, with the right headers. If a client can't host files on the `.well-known` path, we use the DNS option. - **We keep it in sync.** When a client adds a capability or changes a rule, the manifest updates with it. - **We add the trust manifest** when the registries our clients care about start to require one. The client's work: none. Back to the hotel. A guest tells their agent: "3 nights in Paris for the family, use my points." If the agent searches an ARD registry, it finds the hotel's own booking capability, connects through the 42A layer, and gets the member rate, the points balance and the brand's offers. The hotel gets a direct booking, before the agent ever reaches an OTA. If ARD wins, our clients are already there. If it doesn't, they lost nothing. That is the deal we want to offer for every standard that comes next. ### Sources - [Announcing the Agentic Resource Discovery specification](https://developers.googleblog.com/announcing-the-agentic-resource-discovery-specification/), Google Developers Blog - [ARD Specification v0.91](https://agenticresourcediscovery.org/spec/) - [How to publish an ARD manifest](https://agenticresourcediscovery.org/how_to_publish/) - [Connect ChatGPT to an ARD registry](https://agenticresourcediscovery.org/connect/chatgpt/) - [Agentic Resources: measured adoption](https://agenticresources.dev/) - [Helping agents discover my site search with ARD](https://dri.es/helping-agents-discover-my-site-search-with-agentic-resource-discovery), Dries Buytaert - [Google, Microsoft back ARD spec](https://aiweekly.co/alerts/google-microsoft-back-ard-spec-to-counter-anthropics-mcp), AI Weekly